ortools.constraint_solver.pywrapcp
1# This file was automatically generated by SWIG (https://www.swig.org). 2# Version 4.1.1 3# 4# Do not make changes to this file unless you know what you are doing - modify 5# the SWIG interface file instead. 6 7from sys import version_info as _swig_python_version_info 8# Import the low-level C/C++ module 9if __package__ or "." in __name__: 10 from . import _pywrapcp 11else: 12 import _pywrapcp 13 14try: 15 import builtins as __builtin__ 16except ImportError: 17 import __builtin__ 18 19def _swig_repr(self): 20 try: 21 strthis = "proxy of " + self.this.__repr__() 22 except __builtin__.Exception: 23 strthis = "" 24 return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,) 25 26 27def _swig_setattr_nondynamic_instance_variable(set): 28 def set_instance_attr(self, name, value): 29 if name == "this": 30 set(self, name, value) 31 elif name == "thisown": 32 self.this.own(value) 33 elif hasattr(self, name) and isinstance(getattr(type(self), name), property): 34 set(self, name, value) 35 else: 36 raise AttributeError("You cannot add instance attributes to %s" % self) 37 return set_instance_attr 38 39 40def _swig_setattr_nondynamic_class_variable(set): 41 def set_class_attr(cls, name, value): 42 if hasattr(cls, name) and not isinstance(getattr(cls, name), property): 43 set(cls, name, value) 44 else: 45 raise AttributeError("You cannot add class attributes to %s" % cls) 46 return set_class_attr 47 48 49def _swig_add_metaclass(metaclass): 50 """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass""" 51 def wrapper(cls): 52 return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy()) 53 return wrapper 54 55 56class _SwigNonDynamicMeta(type): 57 """Meta class to enforce nondynamic attributes (no new attributes) for a class""" 58 __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__) 59 60 61import weakref 62 63class DefaultPhaseParameters(object): 64 r""" 65 This struct holds all parameters for the default search. 66 DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. 67 Note this is for advanced users only. 68 """ 69 70 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 71 __repr__ = _swig_repr 72 CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT 73 CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT 74 CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT 75 SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT 76 SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT 77 NONE = _pywrapcp.DefaultPhaseParameters_NONE 78 NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL 79 VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE 80 var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r""" 81 This parameter describes how the next variable to instantiate 82 will be chosen. 83 """) 84 value_selection_schema = property(_pywrapcp.DefaultPhaseParameters_value_selection_schema_get, _pywrapcp.DefaultPhaseParameters_value_selection_schema_set, doc=r""" This parameter describes which value to select for a given var.""") 85 initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r""" 86 Maximum number of intervals that the initialization of impacts will scan 87 per variable. 88 """) 89 run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r""" 90 The default phase will run heuristics periodically. This parameter 91 indicates if we should run all heuristics, or a randomly selected 92 one. 93 """) 94 heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r""" 95 The distance in nodes between each run of the heuristics. A 96 negative or null value will mean that we will not run heuristics 97 at all. 98 """) 99 heuristic_num_failures_limit = property(_pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_get, _pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_set, doc=r""" The failure limit for each heuristic that we run.""") 100 persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r""" 101 Whether to keep the impact from the first search for other searches, 102 or to recompute the impact for each new search. 103 """) 104 random_seed = property(_pywrapcp.DefaultPhaseParameters_random_seed_get, _pywrapcp.DefaultPhaseParameters_random_seed_set, doc=r""" Seed used to initialize the random part in some heuristics.""") 105 display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r""" 106 This represents the amount of information displayed by the default search. 107 NONE means no display, VERBOSE means extra information. 108 """) 109 decision_builder = property(_pywrapcp.DefaultPhaseParameters_decision_builder_get, _pywrapcp.DefaultPhaseParameters_decision_builder_set, doc=r""" When defined, this overrides the default impact based decision builder.""") 110 111 def __init__(self): 112 _pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters()) 113 __swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters 114 115# Register DefaultPhaseParameters in _pywrapcp: 116_pywrapcp.DefaultPhaseParameters_swigregister(DefaultPhaseParameters) 117class Solver(object): 118 r""" 119 Solver Class 120 121 A solver represents the main computation engine. It implements the entire 122 range of Constraint Programming protocols: 123 - Reversibility 124 - Propagation 125 - Search 126 127 Usually, Constraint Programming code consists of 128 - the creation of the Solver, 129 - the creation of the decision variables of the model, 130 - the creation of the constraints of the model and their addition to the 131 solver() through the AddConstraint() method, 132 - the creation of the main DecisionBuilder class, 133 - the launch of the solve() method with the decision builder. 134 135 For the time being, Solver is neither MT_SAFE nor MT_HOT. 136 """ 137 138 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 139 __repr__ = _swig_repr 140 INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT 141 r""" The default behavior is CHOOSE_FIRST_UNBOUND.""" 142 INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE 143 r""" The simple selection is CHOOSE_FIRST_UNBOUND.""" 144 CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND 145 r""" 146 Select the first unbound variable. 147 Variables are considered in the order of the vector of IntVars used 148 to create the selector. 149 """ 150 CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM 151 r""" Randomly select one of the remaining unbound variables.""" 152 CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN 153 r""" 154 Among unbound variables, select the variable with the smallest size, 155 i.e., the smallest number of possible values. 156 In case of a tie, the selected variables is the one with the lowest min 157 value. 158 In case of a tie, the first one is selected, first being defined by the 159 order in the vector of IntVars used to create the selector. 160 """ 161 CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN 162 r""" 163 Among unbound variables, select the variable with the smallest size, 164 i.e., the smallest number of possible values. 165 In case of a tie, the selected variable is the one with the highest min 166 value. 167 In case of a tie, the first one is selected, first being defined by the 168 order in the vector of IntVars used to create the selector. 169 """ 170 CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX 171 r""" 172 Among unbound variables, select the variable with the smallest size, 173 i.e., the smallest number of possible values. 174 In case of a tie, the selected variables is the one with the lowest max 175 value. 176 In case of a tie, the first one is selected, first being defined by the 177 order in the vector of IntVars used to create the selector. 178 """ 179 CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX 180 r""" 181 Among unbound variables, select the variable with the smallest size, 182 i.e., the smallest number of possible values. 183 In case of a tie, the selected variable is the one with the highest max 184 value. 185 In case of a tie, the first one is selected, first being defined by the 186 order in the vector of IntVars used to create the selector. 187 """ 188 CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN 189 r""" 190 Among unbound variables, select the variable with the smallest minimal 191 value. 192 In case of a tie, the first one is selected, "first" defined by the 193 order in the vector of IntVars used to create the selector. 194 """ 195 CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX 196 r""" 197 Among unbound variables, select the variable with the highest maximal 198 value. 199 In case of a tie, the first one is selected, first being defined by the 200 order in the vector of IntVars used to create the selector. 201 """ 202 CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE 203 r""" 204 Among unbound variables, select the variable with the smallest size. 205 In case of a tie, the first one is selected, first being defined by the 206 order in the vector of IntVars used to create the selector. 207 """ 208 CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE 209 r""" 210 Among unbound variables, select the variable with the highest size. 211 In case of a tie, the first one is selected, first being defined by the 212 order in the vector of IntVars used to create the selector. 213 """ 214 CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN 215 r""" 216 Among unbound variables, select the variable with the largest 217 gap between the first and the second values of the domain. 218 """ 219 CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH 220 r""" 221 Selects the next unbound variable on a path, the path being defined by 222 the variables: var[i] corresponds to the index of the next of i. 223 """ 224 INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT 225 r""" The default behavior is ASSIGN_MIN_VALUE.""" 226 INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE 227 r""" The simple selection is ASSIGN_MIN_VALUE.""" 228 ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE 229 r""" Selects the min value of the selected variable.""" 230 ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE 231 r""" Selects the max value of the selected variable.""" 232 ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE 233 r""" Selects randomly one of the possible values of the selected variable.""" 234 ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE 235 r""" 236 Selects the first possible value which is the closest to the center 237 of the domain of the selected variable. 238 The center is defined as (min + max) / 2. 239 """ 240 SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF 241 r""" 242 Split the domain in two around the center, and choose the lower 243 part first. 244 """ 245 SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF 246 r""" 247 Split the domain in two around the center, and choose the lower 248 part first. 249 """ 250 SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT 251 SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE 252 CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD 253 CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD 254 INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT 255 r""" The default is INTERVAL_SET_TIMES_FORWARD.""" 256 INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE 257 r""" The simple is INTERVAL_SET_TIMES_FORWARD.""" 258 INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD 259 r""" 260 Selects the variable with the lowest starting time of all variables, 261 and fixes its starting time to this lowest value. 262 """ 263 INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD 264 r""" 265 Selects the variable with the highest ending time of all variables, 266 and fixes the ending time to this highest values. 267 """ 268 TWOOPT = _pywrapcp.Solver_TWOOPT 269 r""" 270 Operator which reverses a sub-chain of a path. It is called TwoOpt 271 because it breaks two arcs on the path; resulting paths are called 272 two-optimal. 273 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 274 (where (1, 5) are first and last nodes of the path and can therefore not 275 be moved): 276 1 -> [3 -> 2] -> 4 -> 5 277 1 -> [4 -> 3 -> 2] -> 5 278 1 -> 2 -> [4 -> 3] -> 5 279 """ 280 OROPT = _pywrapcp.Solver_OROPT 281 r""" 282 Relocate: OROPT and RELOCATE. 283 Operator which moves a sub-chain of a path to another position; the 284 specified chain length is the fixed length of the chains being moved. 285 When this length is 1, the operator simply moves a node to another 286 position. 287 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain 288 length of 2 (where (1, 5) are first and last nodes of the path and can 289 therefore not be moved): 290 1 -> 4 -> [2 -> 3] -> 5 291 1 -> [3 -> 4] -> 2 -> 5 292 293 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent 294 to the OrOpt operator on a path. The OrOpt operator is a limited 295 version of 3Opt (breaks 3 arcs on a path). 296 """ 297 RELOCATE = _pywrapcp.Solver_RELOCATE 298 r""" Relocate neighborhood with length of 1 (see OROPT comment).""" 299 EXCHANGE = _pywrapcp.Solver_EXCHANGE 300 r""" 301 Operator which exchanges the positions of two nodes. 302 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 303 (where (1, 5) are first and last nodes of the path and can therefore not 304 be moved): 305 1 -> [3] -> [2] -> 4 -> 5 306 1 -> [4] -> 3 -> [2] -> 5 307 1 -> 2 -> [4] -> [3] -> 5 308 """ 309 CROSS = _pywrapcp.Solver_CROSS 310 r""" 311 Operator which cross exchanges the starting chains of 2 paths, including 312 exchanging the whole paths. 313 First and last nodes are not moved. 314 Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 315 (where (1, 5) and (6, 8) are first and last nodes of the paths and can 316 therefore not be moved): 317 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 318 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 319 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8 320 """ 321 MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE 322 r""" 323 Operator which inserts an inactive node into a path. 324 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 325 (where 1 and 4 are first and last nodes of the path) are: 326 1 -> [5] -> 2 -> 3 -> 4 327 1 -> 2 -> [5] -> 3 -> 4 328 1 -> 2 -> 3 -> [5] -> 4 329 """ 330 MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE 331 r""" 332 Operator which makes path nodes inactive. 333 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 334 first and last nodes of the path) are: 335 1 -> 3 -> 4 with 2 inactive 336 1 -> 2 -> 4 with 3 inactive 337 """ 338 MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE 339 r""" 340 Operator which makes a "chain" of path nodes inactive. 341 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 342 first and last nodes of the path) are: 343 1 -> 3 -> 4 with 2 inactive 344 1 -> 2 -> 4 with 3 inactive 345 1 -> 4 with 2 and 3 inactive 346 """ 347 SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE 348 r""" 349 Operator which replaces an active node by an inactive one. 350 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 351 (where 1 and 4 are first and last nodes of the path) are: 352 1 -> [5] -> 3 -> 4 with 2 inactive 353 1 -> 2 -> [5] -> 4 with 3 inactive 354 """ 355 EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE 356 r""" 357 Operator which makes an inactive node active and an active one inactive. 358 It is similar to SwapActiveOperator except that it tries to insert the 359 inactive node in all possible positions instead of just the position of 360 the node made inactive. 361 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 362 (where 1 and 4 are first and last nodes of the path) are: 363 1 -> [5] -> 3 -> 4 with 2 inactive 364 1 -> 3 -> [5] -> 4 with 2 inactive 365 1 -> [5] -> 2 -> 4 with 3 inactive 366 1 -> 2 -> [5] -> 4 with 3 inactive 367 """ 368 PATHLNS = _pywrapcp.Solver_PATHLNS 369 r""" 370 Operator which relaxes two sub-chains of three consecutive arcs each. 371 Each sub-chain is defined by a start node and the next three arcs. Those 372 six arcs are relaxed to build a new neighbor. 373 PATHLNS explores all possible pairs of starting nodes and so defines 374 n^2 neighbors, n being the number of nodes. 375 Note that the two sub-chains can be part of the same path; they even may 376 overlap. 377 """ 378 FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS 379 r""" 380 Operator which relaxes one entire path and all inactive nodes, thus 381 defining num_paths neighbors. 382 """ 383 UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS 384 r""" 385 Operator which relaxes all inactive nodes and one sub-chain of six 386 consecutive arcs. That way the path can be improved by inserting 387 inactive nodes or swapping arcs. 388 """ 389 INCREMENT = _pywrapcp.Solver_INCREMENT 390 r""" 391 Operator which defines one neighbor per variable. Each neighbor tries to 392 increment by one the value of the corresponding variable. When a new 393 solution is found the neighborhood is rebuilt from scratch, i.e., tries 394 to increment values in the variable order. 395 Consider for instance variables x and y. x is incremented one by one to 396 its max, and when it is not possible to increment x anymore, y is 397 incremented once. If this is a solution, then next neighbor tries to 398 increment x. 399 """ 400 DECREMENT = _pywrapcp.Solver_DECREMENT 401 r""" 402 Operator which defines a neighborhood to decrement values. 403 The behavior is the same as INCREMENT, except values are decremented 404 instead of incremented. 405 """ 406 SIMPLELNS = _pywrapcp.Solver_SIMPLELNS 407 r""" 408 Operator which defines one neighbor per variable. Each neighbor relaxes 409 one variable. 410 When a new solution is found the neighborhood is rebuilt from scratch. 411 Consider for instance variables x and y. First x is relaxed and the 412 solver is looking for the best possible solution (with only x relaxed). 413 Then y is relaxed, and the solver is looking for a new solution. 414 If a new solution is found, then the next variable to be relaxed is x. 415 """ 416 GE = _pywrapcp.Solver_GE 417 r""" Move is accepted when the current objective value >= objective.Min.""" 418 LE = _pywrapcp.Solver_LE 419 r""" Move is accepted when the current objective value <= objective.Max.""" 420 EQ = _pywrapcp.Solver_EQ 421 r""" 422 Move is accepted when the current objective value is in the interval 423 objective.Min .. objective.Max. 424 """ 425 DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY 426 r""" 427 DELAYED_PRIORITY is the lowest priority: Demons will be processed after 428 VAR_PRIORITY and NORMAL_PRIORITY demons. 429 """ 430 VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY 431 r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.""" 432 NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY 433 r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first.""" 434 435 def __init__(self, *args): 436 _pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args)) 437 438 self.__python_constraints = [] 439 440 441 442 __swig_destroy__ = _pywrapcp.delete_Solver 443 444 def Parameters(self): 445 r""" Stored Parameters.""" 446 return _pywrapcp.Solver_Parameters(self) 447 448 @staticmethod 449 def DefaultSolverParameters(): 450 r""" Create a ConstraintSolverParameters proto with all the default values.""" 451 return _pywrapcp.Solver_DefaultSolverParameters() 452 453 def AddConstraint(self, c): 454 r""" 455 Adds the constraint 'c' to the model. 456 457 After calling this method, and until there is a backtrack that undoes the 458 addition, any assignment of variables to values must satisfy the given 459 constraint in order to be considered feasible. There are two fairly 460 different use cases: 461 462 - the most common use case is modeling: the given constraint is really 463 part of the problem that the user is trying to solve. In this use case, 464 AddConstraint is called outside of search (i.e., with state() == 465 OUTSIDE_SEARCH). Most users should only use AddConstraint in this 466 way. In this case, the constraint will belong to the model forever: it 467 cannot be removed by backtracking. 468 469 - a rarer use case is that 'c' is not a real constraint of the model. It 470 may be a constraint generated by a branching decision (a constraint whose 471 goal is to restrict the search space), a symmetry breaking constraint (a 472 constraint that does restrict the search space, but in a way that cannot 473 have an impact on the quality of the solutions in the subtree), or an 474 inferred constraint that, while having no semantic value to the model (it 475 does not restrict the set of solutions), is worth having because we 476 believe it may strengthen the propagation. In these cases, it happens 477 that the constraint is added during the search (i.e., with state() == 478 IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is 479 added during a search, it applies only to the subtree of the search tree 480 rooted at the current node, and will be automatically removed by 481 backtracking. 482 483 This method does not take ownership of the constraint. If the constraint 484 has been created by any factory method (Solver::MakeXXX), it will 485 automatically be deleted. However, power users who implement their own 486 constraints should do: solver.AddConstraint(solver.RevAlloc(new 487 MyConstraint(...)); 488 """ 489 return _pywrapcp.Solver_AddConstraint(self, c) 490 491 def Solve(self, *args): 492 return _pywrapcp.Solver_Solve(self, *args) 493 494 def NewSearch(self, *args): 495 return _pywrapcp.Solver_NewSearch(self, *args) 496 497 def NextSolution(self): 498 return _pywrapcp.Solver_NextSolution(self) 499 500 def RestartSearch(self): 501 return _pywrapcp.Solver_RestartSearch(self) 502 503 def EndSearch(self): 504 return _pywrapcp.Solver_EndSearch(self) 505 506 def SolveAndCommit(self, *args): 507 return _pywrapcp.Solver_SolveAndCommit(self, *args) 508 509 def CheckAssignment(self, solution): 510 r""" Checks whether the given assignment satisfies all relevant constraints.""" 511 return _pywrapcp.Solver_CheckAssignment(self, solution) 512 513 def CheckConstraint(self, ct): 514 r""" 515 Checks whether adding this constraint will lead to an immediate 516 failure. It will return false if the model is already inconsistent, or if 517 adding the constraint makes it inconsistent. 518 """ 519 return _pywrapcp.Solver_CheckConstraint(self, ct) 520 521 def Fail(self): 522 r""" Abandon the current branch in the search tree. A backtrack will follow.""" 523 return _pywrapcp.Solver_Fail(self) 524 525 @staticmethod 526 def MemoryUsage(): 527 r""" Current memory usage in bytes""" 528 return _pywrapcp.Solver_MemoryUsage() 529 530 def WallTime(self): 531 r""" 532 DEPRECATED: Use Now() instead. 533 Time elapsed, in ms since the creation of the solver. 534 """ 535 return _pywrapcp.Solver_WallTime(self) 536 537 def Branches(self): 538 r""" The number of branches explored since the creation of the solver.""" 539 return _pywrapcp.Solver_Branches(self) 540 541 def Solutions(self): 542 r""" The number of solutions found since the start of the search.""" 543 return _pywrapcp.Solver_Solutions(self) 544 545 def Failures(self): 546 r""" The number of failures encountered since the creation of the solver.""" 547 return _pywrapcp.Solver_Failures(self) 548 549 def AcceptedNeighbors(self): 550 r""" The number of accepted neighbors.""" 551 return _pywrapcp.Solver_AcceptedNeighbors(self) 552 553 def Stamp(self): 554 r""" 555 The stamp indicates how many moves in the search tree we have performed. 556 It is useful to detect if we need to update same lazy structures. 557 """ 558 return _pywrapcp.Solver_Stamp(self) 559 560 def FailStamp(self): 561 r""" The fail_stamp() is incremented after each backtrack.""" 562 return _pywrapcp.Solver_FailStamp(self) 563 564 def IntVar(self, *args): 565 r""" 566 *Overload 1:* 567 MakeIntVar will create the best range based int var for the bounds given. 568 569 | 570 571 *Overload 2:* 572 MakeIntVar will create a variable with the given sparse domain. 573 574 | 575 576 *Overload 3:* 577 MakeIntVar will create a variable with the given sparse domain. 578 579 | 580 581 *Overload 4:* 582 MakeIntVar will create the best range based int var for the bounds given. 583 584 | 585 586 *Overload 5:* 587 MakeIntVar will create a variable with the given sparse domain. 588 589 | 590 591 *Overload 6:* 592 MakeIntVar will create a variable with the given sparse domain. 593 """ 594 return _pywrapcp.Solver_IntVar(self, *args) 595 596 def BoolVar(self, *args): 597 r""" 598 *Overload 1:* 599 MakeBoolVar will create a variable with a {0, 1} domain. 600 601 | 602 603 *Overload 2:* 604 MakeBoolVar will create a variable with a {0, 1} domain. 605 """ 606 return _pywrapcp.Solver_BoolVar(self, *args) 607 608 def IntConst(self, *args): 609 r""" 610 *Overload 1:* 611 IntConst will create a constant expression. 612 613 | 614 615 *Overload 2:* 616 IntConst will create a constant expression. 617 """ 618 return _pywrapcp.Solver_IntConst(self, *args) 619 620 def Sum(self, vars): 621 r""" sum of all vars.""" 622 return _pywrapcp.Solver_Sum(self, vars) 623 624 def ScalProd(self, *args): 625 r""" 626 *Overload 1:* 627 scalar product 628 629 | 630 631 *Overload 2:* 632 scalar product 633 """ 634 return _pywrapcp.Solver_ScalProd(self, *args) 635 636 def MonotonicElement(self, values, increasing, index): 637 r""" 638 Function based element. The constraint takes ownership of the 639 callback. The callback must be monotonic. It must be able to 640 cope with any possible value in the domain of 'index' 641 (potentially negative ones too). Furtermore, monotonicity is not 642 checked. Thus giving a non-monotonic function, or specifying an 643 incorrect increasing parameter will result in undefined behavior. 644 """ 645 return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index) 646 647 def Element(self, *args): 648 r""" 649 *Overload 1:* 650 values[index] 651 652 | 653 654 *Overload 2:* 655 values[index] 656 657 | 658 659 *Overload 3:* 660 Function-based element. The constraint takes ownership of the 661 callback. The callback must be able to cope with any possible 662 value in the domain of 'index' (potentially negative ones too). 663 664 | 665 666 *Overload 4:* 667 2D version of function-based element expression, values(expr1, expr2). 668 669 | 670 671 *Overload 5:* 672 vars[expr] 673 """ 674 return _pywrapcp.Solver_Element(self, *args) 675 676 def IndexExpression(self, vars, value): 677 r""" 678 Returns the expression expr such that vars[expr] == value. 679 It assumes that vars are all different. 680 """ 681 return _pywrapcp.Solver_IndexExpression(self, vars, value) 682 683 def Min(self, *args): 684 r""" 685 *Overload 1:* 686 std::min(vars) 687 688 | 689 690 *Overload 2:* 691 std::min (left, right) 692 693 | 694 695 *Overload 3:* 696 std::min(expr, value) 697 698 | 699 700 *Overload 4:* 701 std::min(expr, value) 702 """ 703 return _pywrapcp.Solver_Min(self, *args) 704 705 def Max(self, *args): 706 r""" 707 *Overload 1:* 708 std::max(vars) 709 710 | 711 712 *Overload 2:* 713 std::max(left, right) 714 715 | 716 717 *Overload 3:* 718 std::max(expr, value) 719 720 | 721 722 *Overload 4:* 723 std::max(expr, value) 724 """ 725 return _pywrapcp.Solver_Max(self, *args) 726 727 def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost): 728 r""" Convex piecewise function.""" 729 return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost) 730 731 def SemiContinuousExpr(self, expr, fixed_charge, step): 732 r""" 733 Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) 734 a >= 0 and b >= 0 735 """ 736 return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step) 737 738 def ConditionalExpression(self, condition, expr, unperformed_value): 739 r""" Conditional Expr condition ? expr : unperformed_value""" 740 return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value) 741 742 def TrueConstraint(self): 743 r""" This constraint always succeeds.""" 744 return _pywrapcp.Solver_TrueConstraint(self) 745 746 def FalseConstraint(self, *args): 747 return _pywrapcp.Solver_FalseConstraint(self, *args) 748 749 def IsEqualCstCt(self, var, value, boolvar): 750 r""" boolvar == (var == value)""" 751 return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar) 752 753 def IsEqualCstVar(self, var, value): 754 r""" status var of (var == value)""" 755 return _pywrapcp.Solver_IsEqualCstVar(self, var, value) 756 757 def IsEqualCt(self, v1, v2, b): 758 r""" b == (v1 == v2)""" 759 return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b) 760 761 def IsEqualVar(self, v1, v2): 762 r""" status var of (v1 == v2)""" 763 return _pywrapcp.Solver_IsEqualVar(self, v1, v2) 764 765 def IsDifferentCstCt(self, var, value, boolvar): 766 r""" boolvar == (var != value)""" 767 return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar) 768 769 def IsDifferentCstVar(self, var, value): 770 r""" status var of (var != value)""" 771 return _pywrapcp.Solver_IsDifferentCstVar(self, var, value) 772 773 def IsDifferentVar(self, v1, v2): 774 r""" status var of (v1 != v2)""" 775 return _pywrapcp.Solver_IsDifferentVar(self, v1, v2) 776 777 def IsDifferentCt(self, v1, v2, b): 778 r""" b == (v1 != v2)""" 779 return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b) 780 781 def IsLessOrEqualCstCt(self, var, value, boolvar): 782 r""" boolvar == (var <= value)""" 783 return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar) 784 785 def IsLessOrEqualCstVar(self, var, value): 786 r""" status var of (var <= value)""" 787 return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value) 788 789 def IsLessOrEqualVar(self, left, right): 790 r""" status var of (left <= right)""" 791 return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right) 792 793 def IsLessOrEqualCt(self, left, right, b): 794 r""" b == (left <= right)""" 795 return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b) 796 797 def IsGreaterOrEqualCstCt(self, var, value, boolvar): 798 r""" boolvar == (var >= value)""" 799 return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar) 800 801 def IsGreaterOrEqualCstVar(self, var, value): 802 r""" status var of (var >= value)""" 803 return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value) 804 805 def IsGreaterOrEqualVar(self, left, right): 806 r""" status var of (left >= right)""" 807 return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right) 808 809 def IsGreaterOrEqualCt(self, left, right, b): 810 r""" b == (left >= right)""" 811 return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b) 812 813 def IsGreaterCstCt(self, v, c, b): 814 r""" b == (v > c)""" 815 return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b) 816 817 def IsGreaterCstVar(self, var, value): 818 r""" status var of (var > value)""" 819 return _pywrapcp.Solver_IsGreaterCstVar(self, var, value) 820 821 def IsGreaterVar(self, left, right): 822 r""" status var of (left > right)""" 823 return _pywrapcp.Solver_IsGreaterVar(self, left, right) 824 825 def IsGreaterCt(self, left, right, b): 826 r""" b == (left > right)""" 827 return _pywrapcp.Solver_IsGreaterCt(self, left, right, b) 828 829 def IsLessCstCt(self, v, c, b): 830 r""" b == (v < c)""" 831 return _pywrapcp.Solver_IsLessCstCt(self, v, c, b) 832 833 def IsLessCstVar(self, var, value): 834 r""" status var of (var < value)""" 835 return _pywrapcp.Solver_IsLessCstVar(self, var, value) 836 837 def IsLessVar(self, left, right): 838 r""" status var of (left < right)""" 839 return _pywrapcp.Solver_IsLessVar(self, left, right) 840 841 def IsLessCt(self, left, right, b): 842 r""" b == (left < right)""" 843 return _pywrapcp.Solver_IsLessCt(self, left, right, b) 844 845 def SumLessOrEqual(self, vars, cst): 846 r""" Variation on arrays.""" 847 return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst) 848 849 def SumGreaterOrEqual(self, vars, cst): 850 return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst) 851 852 def SumEquality(self, *args): 853 return _pywrapcp.Solver_SumEquality(self, *args) 854 855 def ScalProdEquality(self, *args): 856 return _pywrapcp.Solver_ScalProdEquality(self, *args) 857 858 def ScalProdGreaterOrEqual(self, *args): 859 return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args) 860 861 def ScalProdLessOrEqual(self, *args): 862 return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args) 863 864 def MinEquality(self, vars, min_var): 865 return _pywrapcp.Solver_MinEquality(self, vars, min_var) 866 867 def MaxEquality(self, vars, max_var): 868 return _pywrapcp.Solver_MaxEquality(self, vars, max_var) 869 870 def ElementEquality(self, *args): 871 return _pywrapcp.Solver_ElementEquality(self, *args) 872 873 def AbsEquality(self, var, abs_var): 874 r""" Creates the constraint abs(var) == abs_var.""" 875 return _pywrapcp.Solver_AbsEquality(self, var, abs_var) 876 877 def IndexOfConstraint(self, vars, index, target): 878 r""" 879 This constraint is a special case of the element constraint with 880 an array of integer variables, where the variables are all 881 different and the index variable is constrained such that 882 vars[index] == target. 883 """ 884 return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target) 885 886 def ConstraintInitialPropagateCallback(self, ct): 887 r""" 888 This method is a specialized case of the MakeConstraintDemon 889 method to call the InitiatePropagate of the constraint 'ct'. 890 """ 891 return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct) 892 893 def DelayedConstraintInitialPropagateCallback(self, ct): 894 r""" 895 This method is a specialized case of the MakeConstraintDemon 896 method to call the InitiatePropagate of the constraint 'ct' with 897 low priority. 898 """ 899 return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct) 900 901 def ClosureDemon(self, closure): 902 r""" Creates a demon from a closure.""" 903 return _pywrapcp.Solver_ClosureDemon(self, closure) 904 905 def BetweenCt(self, expr, l, u): 906 r""" (l <= expr <= u)""" 907 return _pywrapcp.Solver_BetweenCt(self, expr, l, u) 908 909 def IsBetweenCt(self, expr, l, u, b): 910 r""" b == (l <= expr <= u)""" 911 return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b) 912 913 def IsBetweenVar(self, v, l, u): 914 return _pywrapcp.Solver_IsBetweenVar(self, v, l, u) 915 916 def MemberCt(self, *args): 917 return _pywrapcp.Solver_MemberCt(self, *args) 918 919 def NotMemberCt(self, *args): 920 r""" 921 *Overload 1:* 922 expr not in set. 923 924 | 925 926 *Overload 2:* 927 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 928 929 | 930 931 *Overload 3:* 932 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 933 """ 934 return _pywrapcp.Solver_NotMemberCt(self, *args) 935 936 def IsMemberCt(self, *args): 937 return _pywrapcp.Solver_IsMemberCt(self, *args) 938 939 def IsMemberVar(self, *args): 940 return _pywrapcp.Solver_IsMemberVar(self, *args) 941 942 def Count(self, *args): 943 r""" 944 *Overload 1:* 945 |{i | vars[i] == value}| == max_count 946 947 | 948 949 *Overload 2:* 950 |{i | vars[i] == value}| == max_count 951 """ 952 return _pywrapcp.Solver_Count(self, *args) 953 954 def Distribute(self, *args): 955 r""" 956 *Overload 1:* 957 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 958 959 | 960 961 *Overload 2:* 962 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 963 964 | 965 966 *Overload 3:* 967 Aggregated version of count: |{i | v[i] == j}| == cards[j] 968 969 | 970 971 *Overload 4:* 972 Aggregated version of count with bounded cardinalities: 973 forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max 974 975 | 976 977 *Overload 5:* 978 Aggregated version of count with bounded cardinalities: 979 forall j in 0 .. card_size - 1: 980 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 981 982 | 983 984 *Overload 6:* 985 Aggregated version of count with bounded cardinalities: 986 forall j in 0 .. card_size - 1: 987 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 988 989 | 990 991 *Overload 7:* 992 Aggregated version of count with bounded cardinalities: 993 forall j in 0 .. card_size - 1: 994 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 995 996 | 997 998 *Overload 8:* 999 Aggregated version of count with bounded cardinalities: 1000 forall j in 0 .. card_size - 1: 1001 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 1002 """ 1003 return _pywrapcp.Solver_Distribute(self, *args) 1004 1005 def Deviation(self, vars, deviation_var, total_sum): 1006 r""" 1007 Deviation constraint: 1008 sum_i |n * vars[i] - total_sum| <= deviation_var and 1009 sum_i vars[i] == total_sum 1010 n = #vars 1011 """ 1012 return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum) 1013 1014 def AllDifferent(self, *args): 1015 r""" 1016 *Overload 1:* 1017 All variables are pairwise different. This corresponds to the 1018 stronger version of the propagation algorithm. 1019 1020 | 1021 1022 *Overload 2:* 1023 All variables are pairwise different. If 'stronger_propagation' 1024 is true, stronger, and potentially slower propagation will 1025 occur. This API will be deprecated in the future. 1026 """ 1027 return _pywrapcp.Solver_AllDifferent(self, *args) 1028 1029 def AllDifferentExcept(self, vars, escape_value): 1030 r""" 1031 All variables are pairwise different, unless they are assigned to 1032 the escape value. 1033 """ 1034 return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value) 1035 1036 def SortingConstraint(self, vars, sorted): 1037 r""" 1038 Creates a constraint binding the arrays of variables "vars" and 1039 "sorted_vars": sorted_vars[0] must be equal to the minimum of all 1040 variables in vars, and so on: the value of sorted_vars[i] must be 1041 equal to the i-th value of variables invars. 1042 1043 This constraint propagates in both directions: from "vars" to 1044 "sorted_vars" and vice-versa. 1045 1046 Behind the scenes, this constraint maintains that: 1047 - sorted is always increasing. 1048 - whatever the values of vars, there exists a permutation that 1049 injects its values into the sorted variables. 1050 1051 For more info, please have a look at: 1052 https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf 1053 """ 1054 return _pywrapcp.Solver_SortingConstraint(self, vars, sorted) 1055 1056 def LexicalLess(self, left, right): 1057 r""" 1058 Creates a constraint that enforces that left is lexicographically less 1059 than right. 1060 """ 1061 return _pywrapcp.Solver_LexicalLess(self, left, right) 1062 1063 def LexicalLessOrEqual(self, left, right): 1064 r""" 1065 Creates a constraint that enforces that left is lexicographically less 1066 than or equal to right. 1067 """ 1068 return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right) 1069 1070 def InversePermutationConstraint(self, left, right): 1071 r""" 1072 Creates a constraint that enforces that 'left' and 'right' both 1073 represent permutations of [0..left.size()-1], and that 'right' is 1074 the inverse permutation of 'left', i.e. for all i in 1075 [0..left.size()-1], right[left[i]] = i. 1076 """ 1077 return _pywrapcp.Solver_InversePermutationConstraint(self, left, right) 1078 1079 def NullIntersect(self, first_vars, second_vars): 1080 r""" 1081 Creates a constraint that states that all variables in the first 1082 vector are different from all variables in the second 1083 group. Thus the set of values in the first vector does not 1084 intersect with the set of values in the second vector. 1085 """ 1086 return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars) 1087 1088 def NullIntersectExcept(self, first_vars, second_vars, escape_value): 1089 r""" 1090 Creates a constraint that states that all variables in the first 1091 vector are different from all variables from the second group, 1092 unless they are assigned to the escape value. Thus the set of 1093 values in the first vector minus the escape value does not 1094 intersect with the set of values in the second vector. 1095 """ 1096 return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value) 1097 1098 def Circuit(self, nexts): 1099 r""" Force the "nexts" variable to create a complete Hamiltonian path.""" 1100 return _pywrapcp.Solver_Circuit(self, nexts) 1101 1102 def SubCircuit(self, nexts): 1103 r""" 1104 Force the "nexts" variable to create a complete Hamiltonian path 1105 for those that do not loop upon themselves. 1106 """ 1107 return _pywrapcp.Solver_SubCircuit(self, nexts) 1108 1109 def DelayedPathCumul(self, nexts, active, cumuls, transits): 1110 r""" 1111 Delayed version of the same constraint: propagation on the nexts variables 1112 is delayed until all constraints have propagated. 1113 """ 1114 return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits) 1115 1116 def PathCumul(self, *args): 1117 r""" 1118 *Overload 1:* 1119 Creates a constraint which accumulates values along a path such that: 1120 cumuls[next[i]] = cumuls[i] + transits[i]. 1121 Active variables indicate if the corresponding next variable is active; 1122 this could be useful to model unperformed nodes in a routing problem. 1123 1124 | 1125 1126 *Overload 2:* 1127 Creates a constraint which accumulates values along a path such that: 1128 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). 1129 Active variables indicate if the corresponding next variable is active; 1130 this could be useful to model unperformed nodes in a routing problem. 1131 Ownership of transit_evaluator is taken and it must be a repeatable 1132 callback. 1133 1134 | 1135 1136 *Overload 3:* 1137 Creates a constraint which accumulates values along a path such that: 1138 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. 1139 Active variables indicate if the corresponding next variable is active; 1140 this could be useful to model unperformed nodes in a routing problem. 1141 Ownership of transit_evaluator is taken and it must be a repeatable 1142 callback. 1143 """ 1144 return _pywrapcp.Solver_PathCumul(self, *args) 1145 1146 def AllowedAssignments(self, *args): 1147 r""" 1148 *Overload 1:* 1149 This method creates a constraint where the graph of the relation 1150 between the variables is given in extension. There are 'arity' 1151 variables involved in the relation and the graph is given by a 1152 integer tuple set. 1153 1154 | 1155 1156 *Overload 2:* 1157 Compatibility layer for Python API. 1158 """ 1159 return _pywrapcp.Solver_AllowedAssignments(self, *args) 1160 1161 def TransitionConstraint(self, *args): 1162 return _pywrapcp.Solver_TransitionConstraint(self, *args) 1163 1164 def NonOverlappingBoxesConstraint(self, *args): 1165 return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args) 1166 1167 def Pack(self, vars, number_of_bins): 1168 r""" 1169 This constraint packs all variables onto 'number_of_bins' 1170 variables. For any given variable, a value of 'number_of_bins' 1171 indicates that the variable is not assigned to any bin. 1172 Dimensions, i.e., cumulative constraints on this packing, can be 1173 added directly from the pack class. 1174 """ 1175 return _pywrapcp.Solver_Pack(self, vars, number_of_bins) 1176 1177 def FixedDurationIntervalVar(self, *args): 1178 r""" 1179 *Overload 1:* 1180 Creates an interval var with a fixed duration. The duration must 1181 be greater than 0. If optional is true, then the interval can be 1182 performed or unperformed. If optional is false, then the interval 1183 is always performed. 1184 1185 | 1186 1187 *Overload 2:* 1188 Creates a performed interval var with a fixed duration. The duration must 1189 be greater than 0. 1190 1191 | 1192 1193 *Overload 3:* 1194 Creates an interval var with a fixed duration, and performed_variable. 1195 The duration must be greater than 0. 1196 """ 1197 return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args) 1198 1199 def FixedInterval(self, start, duration, name): 1200 r""" Creates a fixed and performed interval.""" 1201 return _pywrapcp.Solver_FixedInterval(self, start, duration, name) 1202 1203 def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name): 1204 r""" 1205 Creates an interval var by specifying the bounds on start, 1206 duration, and end. 1207 """ 1208 return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name) 1209 1210 def MirrorInterval(self, interval_var): 1211 r""" 1212 Creates an interval var that is the mirror image of the given one, that 1213 is, the interval var obtained by reversing the axis. 1214 """ 1215 return _pywrapcp.Solver_MirrorInterval(self, interval_var) 1216 1217 def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1218 r""" 1219 Creates an interval var with a fixed duration whose start is 1220 synchronized with the start of another interval, with a given 1221 offset. The performed status is also in sync with the performed 1222 status of the given interval variable. 1223 """ 1224 return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1225 1226 def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1227 r""" 1228 Creates an interval var with a fixed duration whose start is 1229 synchronized with the end of another interval, with a given 1230 offset. The performed status is also in sync with the performed 1231 status of the given interval variable. 1232 """ 1233 return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1234 1235 def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1236 r""" 1237 Creates an interval var with a fixed duration whose end is 1238 synchronized with the start of another interval, with a given 1239 offset. The performed status is also in sync with the performed 1240 status of the given interval variable. 1241 """ 1242 return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1243 1244 def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1245 r""" 1246 Creates an interval var with a fixed duration whose end is 1247 synchronized with the end of another interval, with a given 1248 offset. The performed status is also in sync with the performed 1249 status of the given interval variable. 1250 """ 1251 return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1252 1253 def IntervalRelaxedMin(self, interval_var): 1254 r""" 1255 Creates and returns an interval variable that wraps around the given one, 1256 relaxing the min start and end. Relaxing means making unbounded when 1257 optional. If the variable is non-optional, this method returns 1258 interval_var. 1259 1260 More precisely, such an interval variable behaves as follows: 1261 When the underlying must be performed, the returned interval variable 1262 behaves exactly as the underlying; 1263 When the underlying may or may not be performed, the returned interval 1264 variable behaves like the underlying, except that it is unbounded on 1265 the min side; 1266 When the underlying cannot be performed, the returned interval variable 1267 is of duration 0 and must be performed in an interval unbounded on 1268 both sides. 1269 1270 This is very useful to implement propagators that may only modify 1271 the start max or end max. 1272 """ 1273 return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var) 1274 1275 def IntervalRelaxedMax(self, interval_var): 1276 r""" 1277 Creates and returns an interval variable that wraps around the given one, 1278 relaxing the max start and end. Relaxing means making unbounded when 1279 optional. If the variable is non optional, this method returns 1280 interval_var. 1281 1282 More precisely, such an interval variable behaves as follows: 1283 When the underlying must be performed, the returned interval variable 1284 behaves exactly as the underlying; 1285 When the underlying may or may not be performed, the returned interval 1286 variable behaves like the underlying, except that it is unbounded on 1287 the max side; 1288 When the underlying cannot be performed, the returned interval variable 1289 is of duration 0 and must be performed in an interval unbounded on 1290 both sides. 1291 1292 This is very useful for implementing propagators that may only modify 1293 the start min or end min. 1294 """ 1295 return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var) 1296 1297 def TemporalDisjunction(self, *args): 1298 r""" 1299 *Overload 1:* 1300 This constraint implements a temporal disjunction between two 1301 interval vars t1 and t2. 'alt' indicates which alternative was 1302 chosen (alt == 0 is equivalent to t1 before t2). 1303 1304 | 1305 1306 *Overload 2:* 1307 This constraint implements a temporal disjunction between two 1308 interval vars. 1309 """ 1310 return _pywrapcp.Solver_TemporalDisjunction(self, *args) 1311 1312 def DisjunctiveConstraint(self, intervals, name): 1313 r""" 1314 This constraint forces all interval vars into an non-overlapping 1315 sequence. Intervals with zero duration can be scheduled anywhere. 1316 """ 1317 return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name) 1318 1319 def Cumulative(self, *args): 1320 r""" 1321 *Overload 1:* 1322 This constraint forces that, for any integer t, the sum of the demands 1323 corresponding to an interval containing t does not exceed the given 1324 capacity. 1325 1326 Intervals and demands should be vectors of equal size. 1327 1328 Demands should only contain non-negative values. Zero values are 1329 supported, and the corresponding intervals are filtered out, as they 1330 neither impact nor are impacted by this constraint. 1331 1332 | 1333 1334 *Overload 2:* 1335 This constraint forces that, for any integer t, the sum of the demands 1336 corresponding to an interval containing t does not exceed the given 1337 capacity. 1338 1339 Intervals and demands should be vectors of equal size. 1340 1341 Demands should only contain non-negative values. Zero values are 1342 supported, and the corresponding intervals are filtered out, as they 1343 neither impact nor are impacted by this constraint. 1344 1345 | 1346 1347 *Overload 3:* 1348 This constraint forces that, for any integer t, the sum of the demands 1349 corresponding to an interval containing t does not exceed the given 1350 capacity. 1351 1352 Intervals and demands should be vectors of equal size. 1353 1354 Demands should only contain non-negative values. Zero values are 1355 supported, and the corresponding intervals are filtered out, as they 1356 neither impact nor are impacted by this constraint. 1357 1358 | 1359 1360 *Overload 4:* 1361 This constraint enforces that, for any integer t, the sum of the demands 1362 corresponding to an interval containing t does not exceed the given 1363 capacity. 1364 1365 Intervals and demands should be vectors of equal size. 1366 1367 Demands should only contain non-negative values. Zero values are 1368 supported, and the corresponding intervals are filtered out, as they 1369 neither impact nor are impacted by this constraint. 1370 1371 | 1372 1373 *Overload 5:* 1374 This constraint enforces that, for any integer t, the sum of demands 1375 corresponding to an interval containing t does not exceed the given 1376 capacity. 1377 1378 Intervals and demands should be vectors of equal size. 1379 1380 Demands should be positive. 1381 1382 | 1383 1384 *Overload 6:* 1385 This constraint enforces that, for any integer t, the sum of demands 1386 corresponding to an interval containing t does not exceed the given 1387 capacity. 1388 1389 Intervals and demands should be vectors of equal size. 1390 1391 Demands should be positive. 1392 """ 1393 return _pywrapcp.Solver_Cumulative(self, *args) 1394 1395 def Cover(self, vars, target_var): 1396 r""" 1397 This constraint states that the target_var is the convex hull of 1398 the intervals. If none of the interval variables is performed, 1399 then the target var is unperformed too. Also, if the target 1400 variable is unperformed, then all the intervals variables are 1401 unperformed too. 1402 """ 1403 return _pywrapcp.Solver_Cover(self, vars, target_var) 1404 1405 def Assignment(self, *args): 1406 r""" 1407 *Overload 1:* 1408 This method creates an empty assignment. 1409 1410 | 1411 1412 *Overload 2:* 1413 This method creates an assignment which is a copy of 'a'. 1414 """ 1415 return _pywrapcp.Solver_Assignment(self, *args) 1416 1417 def FirstSolutionCollector(self, *args): 1418 r""" 1419 *Overload 1:* 1420 Collect the first solution of the search. 1421 1422 | 1423 1424 *Overload 2:* 1425 Collect the first solution of the search. The variables will need to 1426 be added later. 1427 """ 1428 return _pywrapcp.Solver_FirstSolutionCollector(self, *args) 1429 1430 def LastSolutionCollector(self, *args): 1431 r""" 1432 *Overload 1:* 1433 Collect the last solution of the search. 1434 1435 | 1436 1437 *Overload 2:* 1438 Collect the last solution of the search. The variables will need to 1439 be added later. 1440 """ 1441 return _pywrapcp.Solver_LastSolutionCollector(self, *args) 1442 1443 def BestValueSolutionCollector(self, *args): 1444 r""" 1445 *Overload 1:* 1446 Collect the solution corresponding to the optimal value of the objective 1447 of 'assignment'; if 'assignment' does not have an objective no solution is 1448 collected. This collector only collects one solution corresponding to the 1449 best objective value (the first one found). 1450 1451 | 1452 1453 *Overload 2:* 1454 Collect the solution corresponding to the optimal value of the 1455 objective of the internal assignment; if this assignment does not have an 1456 objective no solution is collected. This collector only collects one 1457 solution corresponding to the best objective value (the first one found). 1458 The variables and objective(s) will need to be added later. 1459 """ 1460 return _pywrapcp.Solver_BestValueSolutionCollector(self, *args) 1461 1462 def AllSolutionCollector(self, *args): 1463 r""" 1464 *Overload 1:* 1465 Collect all solutions of the search. 1466 1467 | 1468 1469 *Overload 2:* 1470 Collect all solutions of the search. The variables will need to 1471 be added later. 1472 """ 1473 return _pywrapcp.Solver_AllSolutionCollector(self, *args) 1474 1475 def Minimize(self, v, step): 1476 r""" Creates a minimization objective.""" 1477 return _pywrapcp.Solver_Minimize(self, v, step) 1478 1479 def Maximize(self, v, step): 1480 r""" Creates a maximization objective.""" 1481 return _pywrapcp.Solver_Maximize(self, v, step) 1482 1483 def Optimize(self, maximize, v, step): 1484 r""" Creates a objective with a given sense (true = maximization).""" 1485 return _pywrapcp.Solver_Optimize(self, maximize, v, step) 1486 1487 def WeightedMinimize(self, *args): 1488 r""" 1489 *Overload 1:* 1490 Creates a minimization weighted objective. The actual objective is 1491 scalar_prod(sub_objectives, weights). 1492 1493 | 1494 1495 *Overload 2:* 1496 Creates a minimization weighted objective. The actual objective is 1497 scalar_prod(sub_objectives, weights). 1498 """ 1499 return _pywrapcp.Solver_WeightedMinimize(self, *args) 1500 1501 def WeightedMaximize(self, *args): 1502 r""" 1503 *Overload 1:* 1504 Creates a maximization weigthed objective. 1505 1506 | 1507 1508 *Overload 2:* 1509 Creates a maximization weigthed objective. 1510 """ 1511 return _pywrapcp.Solver_WeightedMaximize(self, *args) 1512 1513 def WeightedOptimize(self, *args): 1514 r""" 1515 *Overload 1:* 1516 Creates a weighted objective with a given sense (true = maximization). 1517 1518 | 1519 1520 *Overload 2:* 1521 Creates a weighted objective with a given sense (true = maximization). 1522 """ 1523 return _pywrapcp.Solver_WeightedOptimize(self, *args) 1524 1525 def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor): 1526 r""" 1527 MetaHeuristics which try to get the search out of local optima. 1528 Creates a Tabu Search monitor. 1529 In the context of local search the behavior is similar to MakeOptimize(), 1530 creating an objective in a given sense. The behavior differs once a local 1531 optimum is reached: thereafter solutions which degrade the value of the 1532 objective are allowed if they are not "tabu". A solution is "tabu" if it 1533 doesn't respect the following rules: 1534 - improving the best solution found so far 1535 - variables in the "keep" list must keep their value, variables in the 1536 "forbid" list must not take the value they have in the list. 1537 Variables with new values enter the tabu lists after each new solution 1538 found and leave the lists after a given number of iterations (called 1539 tenure). Only the variables passed to the method can enter the lists. 1540 The tabu criterion is softened by the tabu factor which gives the number 1541 of "tabu" violations which is tolerated; a factor of 1 means no violations 1542 allowed; a factor of 0 means all violations are allowed. 1543 """ 1544 return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor) 1545 1546 def SimulatedAnnealing(self, maximize, v, step, initial_temperature): 1547 r""" Creates a Simulated Annealing monitor.""" 1548 return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature) 1549 1550 def LubyRestart(self, scale_factor): 1551 r""" 1552 This search monitor will restart the search periodically. 1553 At the iteration n, it will restart after scale_factor * Luby(n) failures 1554 where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...). 1555 """ 1556 return _pywrapcp.Solver_LubyRestart(self, scale_factor) 1557 1558 def ConstantRestart(self, frequency): 1559 r""" 1560 This search monitor will restart the search periodically after 'frequency' 1561 failures. 1562 """ 1563 return _pywrapcp.Solver_ConstantRestart(self, frequency) 1564 1565 def TimeLimit(self, *args): 1566 return _pywrapcp.Solver_TimeLimit(self, *args) 1567 1568 def BranchesLimit(self, branches): 1569 r""" 1570 Creates a search limit that constrains the number of branches 1571 explored in the search tree. 1572 """ 1573 return _pywrapcp.Solver_BranchesLimit(self, branches) 1574 1575 def FailuresLimit(self, failures): 1576 r""" 1577 Creates a search limit that constrains the number of failures 1578 that can happen when exploring the search tree. 1579 """ 1580 return _pywrapcp.Solver_FailuresLimit(self, failures) 1581 1582 def SolutionsLimit(self, solutions): 1583 r""" 1584 Creates a search limit that constrains the number of solutions found 1585 during the search. 1586 """ 1587 return _pywrapcp.Solver_SolutionsLimit(self, solutions) 1588 1589 def Limit(self, *args): 1590 r""" 1591 *Overload 1:* 1592 Limits the search with the 'time', 'branches', 'failures' and 1593 'solutions' limits. 'smart_time_check' reduces the calls to the wall 1594 1595 | 1596 1597 *Overload 2:* 1598 Creates a search limit from its protobuf description 1599 1600 | 1601 1602 *Overload 3:* 1603 Creates a search limit that is reached when either of the underlying limit 1604 is reached. That is, the returned limit is more stringent than both 1605 argument limits. 1606 """ 1607 return _pywrapcp.Solver_Limit(self, *args) 1608 1609 def CustomLimit(self, limiter): 1610 r""" 1611 Callback-based search limit. Search stops when limiter returns true; if 1612 this happens at a leaf the corresponding solution will be rejected. 1613 """ 1614 return _pywrapcp.Solver_CustomLimit(self, limiter) 1615 1616 def SearchLog(self, *args): 1617 return _pywrapcp.Solver_SearchLog(self, *args) 1618 1619 def SearchTrace(self, prefix): 1620 r""" 1621 Creates a search monitor that will trace precisely the behavior of the 1622 search. Use this only for low level debugging. 1623 """ 1624 return _pywrapcp.Solver_SearchTrace(self, prefix) 1625 1626 def PrintModelVisitor(self): 1627 r""" Prints the model.""" 1628 return _pywrapcp.Solver_PrintModelVisitor(self) 1629 1630 def StatisticsModelVisitor(self): 1631 r""" Displays some nice statistics on the model.""" 1632 return _pywrapcp.Solver_StatisticsModelVisitor(self) 1633 1634 def AssignVariableValue(self, var, val): 1635 r""" Decisions.""" 1636 return _pywrapcp.Solver_AssignVariableValue(self, var, val) 1637 1638 def VariableLessOrEqualValue(self, var, value): 1639 return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value) 1640 1641 def VariableGreaterOrEqualValue(self, var, value): 1642 return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value) 1643 1644 def SplitVariableDomain(self, var, val, start_with_lower_half): 1645 return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half) 1646 1647 def AssignVariableValueOrFail(self, var, value): 1648 return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value) 1649 1650 def AssignVariablesValues(self, vars, values): 1651 return _pywrapcp.Solver_AssignVariablesValues(self, vars, values) 1652 1653 def FailDecision(self): 1654 return _pywrapcp.Solver_FailDecision(self) 1655 1656 def Decision(self, apply, refute): 1657 return _pywrapcp.Solver_Decision(self, apply, refute) 1658 1659 def Compose(self, dbs): 1660 return _pywrapcp.Solver_Compose(self, dbs) 1661 1662 def Try(self, dbs): 1663 return _pywrapcp.Solver_Try(self, dbs) 1664 1665 def DefaultPhase(self, *args): 1666 return _pywrapcp.Solver_DefaultPhase(self, *args) 1667 1668 def ScheduleOrPostpone(self, var, est, marker): 1669 r""" 1670 Returns a decision that tries to schedule a task at a given time. 1671 On the Apply branch, it will set that interval var as performed and set 1672 its start to 'est'. On the Refute branch, it will just update the 1673 'marker' to 'est' + 1. This decision is used in the 1674 INTERVAL_SET_TIMES_FORWARD strategy. 1675 """ 1676 return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker) 1677 1678 def ScheduleOrExpedite(self, var, est, marker): 1679 r""" 1680 Returns a decision that tries to schedule a task at a given time. 1681 On the Apply branch, it will set that interval var as performed and set 1682 its end to 'est'. On the Refute branch, it will just update the 1683 'marker' to 'est' - 1. This decision is used in the 1684 INTERVAL_SET_TIMES_BACKWARD strategy. 1685 """ 1686 return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker) 1687 1688 def RankFirstInterval(self, sequence, index): 1689 r""" 1690 Returns a decision that tries to rank first the ith interval var 1691 in the sequence variable. 1692 """ 1693 return _pywrapcp.Solver_RankFirstInterval(self, sequence, index) 1694 1695 def RankLastInterval(self, sequence, index): 1696 r""" 1697 Returns a decision that tries to rank last the ith interval var 1698 in the sequence variable. 1699 """ 1700 return _pywrapcp.Solver_RankLastInterval(self, sequence, index) 1701 1702 def Phase(self, *args): 1703 return _pywrapcp.Solver_Phase(self, *args) 1704 1705 def DecisionBuilderFromAssignment(self, assignment, db, vars): 1706 r""" 1707 Returns a decision builder for which the left-most leaf corresponds 1708 to assignment, the rest of the tree being explored using 'db'. 1709 """ 1710 return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars) 1711 1712 def ConstraintAdder(self, ct): 1713 r""" 1714 Returns a decision builder that will add the given constraint to 1715 the model. 1716 """ 1717 return _pywrapcp.Solver_ConstraintAdder(self, ct) 1718 1719 def SolveOnce(self, db, monitors): 1720 return _pywrapcp.Solver_SolveOnce(self, db, monitors) 1721 1722 def NestedOptimize(self, *args): 1723 return _pywrapcp.Solver_NestedOptimize(self, *args) 1724 1725 def RestoreAssignment(self, assignment): 1726 r""" 1727 Returns a DecisionBuilder which restores an Assignment 1728 (calls void Assignment::Restore()) 1729 """ 1730 return _pywrapcp.Solver_RestoreAssignment(self, assignment) 1731 1732 def StoreAssignment(self, assignment): 1733 r""" 1734 Returns a DecisionBuilder which stores an Assignment 1735 (calls void Assignment::Store()) 1736 """ 1737 return _pywrapcp.Solver_StoreAssignment(self, assignment) 1738 1739 def Operator(self, *args): 1740 return _pywrapcp.Solver_Operator(self, *args) 1741 1742 def RandomLnsOperator(self, *args): 1743 return _pywrapcp.Solver_RandomLnsOperator(self, *args) 1744 1745 def MoveTowardTargetOperator(self, *args): 1746 r""" 1747 *Overload 1:* 1748 Creates a local search operator that tries to move the assignment of some 1749 variables toward a target. The target is given as an Assignment. This 1750 operator generates neighbors in which the only difference compared to the 1751 current state is that one variable that belongs to the target assignment 1752 is set to its target value. 1753 1754 | 1755 1756 *Overload 2:* 1757 Creates a local search operator that tries to move the assignment of some 1758 variables toward a target. The target is given either as two vectors: a 1759 vector of variables and a vector of associated target values. The two 1760 vectors should be of the same length. This operator generates neighbors in 1761 which the only difference compared to the current state is that one 1762 variable that belongs to the given vector is set to its target value. 1763 """ 1764 return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args) 1765 1766 def ConcatenateOperators(self, *args): 1767 return _pywrapcp.Solver_ConcatenateOperators(self, *args) 1768 1769 def RandomConcatenateOperators(self, *args): 1770 r""" 1771 *Overload 1:* 1772 Randomized version of local search concatenator; calls a random operator 1773 at each call to MakeNextNeighbor(). 1774 1775 | 1776 1777 *Overload 2:* 1778 Randomized version of local search concatenator; calls a random operator 1779 at each call to MakeNextNeighbor(). The provided seed is used to 1780 initialize the random number generator. 1781 """ 1782 return _pywrapcp.Solver_RandomConcatenateOperators(self, *args) 1783 1784 def NeighborhoodLimit(self, op, limit): 1785 r""" 1786 Creates a local search operator that wraps another local search 1787 operator and limits the number of neighbors explored (i.e., calls 1788 to MakeNextNeighbor from the current solution (between two calls 1789 to Start()). When this limit is reached, MakeNextNeighbor() 1790 returns false. The counter is cleared when Start() is called. 1791 """ 1792 return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit) 1793 1794 def LocalSearchPhase(self, *args): 1795 return _pywrapcp.Solver_LocalSearchPhase(self, *args) 1796 1797 def LocalSearchPhaseParameters(self, *args): 1798 return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args) 1799 1800 def TopProgressPercent(self): 1801 r""" 1802 Returns a percentage representing the propress of the search before 1803 reaching the limits of the top-level search (can be called from a nested 1804 solve). 1805 """ 1806 return _pywrapcp.Solver_TopProgressPercent(self) 1807 1808 def SearchDepth(self): 1809 r""" 1810 Gets the search depth of the current active search. Returns -1 if 1811 there is no active search opened. 1812 """ 1813 return _pywrapcp.Solver_SearchDepth(self) 1814 1815 def SearchLeftDepth(self): 1816 r""" 1817 Gets the search left depth of the current active search. Returns -1 if 1818 there is no active search opened. 1819 """ 1820 return _pywrapcp.Solver_SearchLeftDepth(self) 1821 1822 def SolveDepth(self): 1823 r""" 1824 Gets the number of nested searches. It returns 0 outside search, 1825 1 during the top level search, 2 or more in case of nested searches. 1826 """ 1827 return _pywrapcp.Solver_SolveDepth(self) 1828 1829 def Rand64(self, size): 1830 r""" Returns a random value between 0 and 'size' - 1;""" 1831 return _pywrapcp.Solver_Rand64(self, size) 1832 1833 def Rand32(self, size): 1834 r""" Returns a random value between 0 and 'size' - 1;""" 1835 return _pywrapcp.Solver_Rand32(self, size) 1836 1837 def ReSeed(self, seed): 1838 r""" Reseed the solver random generator.""" 1839 return _pywrapcp.Solver_ReSeed(self, seed) 1840 1841 def LocalSearchProfile(self): 1842 r""" Returns local search profiling information in a human readable format.""" 1843 return _pywrapcp.Solver_LocalSearchProfile(self) 1844 1845 def Constraints(self): 1846 r""" 1847 Counts the number of constraints that have been added 1848 to the solver before the search. 1849 """ 1850 return _pywrapcp.Solver_Constraints(self) 1851 1852 def Accept(self, visitor): 1853 r""" Accepts the given model visitor.""" 1854 return _pywrapcp.Solver_Accept(self, visitor) 1855 1856 def FinishCurrentSearch(self): 1857 r""" Tells the solver to kill or restart the current search.""" 1858 return _pywrapcp.Solver_FinishCurrentSearch(self) 1859 1860 def RestartCurrentSearch(self): 1861 return _pywrapcp.Solver_RestartCurrentSearch(self) 1862 1863 def ShouldFail(self): 1864 r""" 1865 These methods are only useful for the SWIG wrappers, which need a way 1866 to externally cause the Solver to fail. 1867 """ 1868 return _pywrapcp.Solver_ShouldFail(self) 1869 1870 def __str__(self): 1871 return _pywrapcp.Solver___str__(self) 1872 1873 def Add(self, ct): 1874 if isinstance(ct, PyConstraint): 1875 self.__python_constraints.append(ct) 1876 self.AddConstraint(ct) 1877 1878 1879 def TreeNoCycle(self, nexts, active, callback=0): 1880 return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback) 1881 1882 def SearchLogWithCallback(self, period, callback): 1883 return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback) 1884 1885 def ElementFunction(self, values, index): 1886 return _pywrapcp.Solver_ElementFunction(self, values, index) 1887 1888 def VarEvalValStrPhase(self, vars, var_evaluator, val_str): 1889 return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str) 1890 1891 def VarStrValEvalPhase(self, vars, var_str, val_eval): 1892 return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval) 1893 1894 def VarEvalValEvalPhase(self, vars, var_eval, val_eval): 1895 return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval) 1896 1897 def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker): 1898 return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker) 1899 1900 def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker): 1901 return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker) 1902 1903 def EvalEvalStrPhase(self, vars, evaluator, str): 1904 return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str) 1905 1906 def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str): 1907 return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str) 1908 1909 def GuidedLocalSearch(self, *args): 1910 return _pywrapcp.Solver_GuidedLocalSearch(self, *args) 1911 1912 def SumObjectiveFilter(self, vars, values, filter_enum): 1913 return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, filter_enum) 1914 1915# Register Solver in _pywrapcp: 1916_pywrapcp.Solver_swigregister(Solver) 1917class BaseObject(object): 1918 r""" 1919 A BaseObject is the root of all reversibly allocated objects. 1920 A DebugString method and the associated << operator are implemented 1921 as a convenience. 1922 """ 1923 1924 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1925 1926 def __init__(self): 1927 if self.__class__ == BaseObject: 1928 _self = None 1929 else: 1930 _self = self 1931 _pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, )) 1932 __swig_destroy__ = _pywrapcp.delete_BaseObject 1933 1934 def DebugString(self): 1935 return _pywrapcp.BaseObject_DebugString(self) 1936 1937 def __str__(self): 1938 return _pywrapcp.BaseObject___str__(self) 1939 1940 def __repr__(self): 1941 return _pywrapcp.BaseObject___repr__(self) 1942 def __disown__(self): 1943 self.this.disown() 1944 _pywrapcp.disown_BaseObject(self) 1945 return weakref.proxy(self) 1946 1947# Register BaseObject in _pywrapcp: 1948_pywrapcp.BaseObject_swigregister(BaseObject) 1949class PropagationBaseObject(BaseObject): 1950 r""" 1951 NOLINT 1952 The PropagationBaseObject is a subclass of BaseObject that is also 1953 friend to the Solver class. It allows accessing methods useful when 1954 writing new constraints or new expressions. 1955 """ 1956 1957 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1958 __repr__ = _swig_repr 1959 1960 def __init__(self, s): 1961 if self.__class__ == PropagationBaseObject: 1962 _self = None 1963 else: 1964 _self = self 1965 _pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s)) 1966 __swig_destroy__ = _pywrapcp.delete_PropagationBaseObject 1967 1968 def DebugString(self): 1969 return _pywrapcp.PropagationBaseObject_DebugString(self) 1970 1971 def solver(self): 1972 return _pywrapcp.PropagationBaseObject_solver(self) 1973 1974 def Name(self): 1975 r""" Object naming.""" 1976 return _pywrapcp.PropagationBaseObject_Name(self) 1977 def __disown__(self): 1978 self.this.disown() 1979 _pywrapcp.disown_PropagationBaseObject(self) 1980 return weakref.proxy(self) 1981 1982# Register PropagationBaseObject in _pywrapcp: 1983_pywrapcp.PropagationBaseObject_swigregister(PropagationBaseObject) 1984class Decision(BaseObject): 1985 r""" 1986 A Decision represents a choice point in the search tree. The two main 1987 methods are Apply() to go left, or Refute() to go right. 1988 """ 1989 1990 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1991 1992 def __init__(self): 1993 if self.__class__ == Decision: 1994 _self = None 1995 else: 1996 _self = self 1997 _pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, )) 1998 __swig_destroy__ = _pywrapcp.delete_Decision 1999 2000 def ApplyWrapper(self, s): 2001 r""" Apply will be called first when the decision is executed.""" 2002 return _pywrapcp.Decision_ApplyWrapper(self, s) 2003 2004 def RefuteWrapper(self, s): 2005 r""" Refute will be called after a backtrack.""" 2006 return _pywrapcp.Decision_RefuteWrapper(self, s) 2007 2008 def DebugString(self): 2009 return _pywrapcp.Decision_DebugString(self) 2010 2011 def __repr__(self): 2012 return _pywrapcp.Decision___repr__(self) 2013 2014 def __str__(self): 2015 return _pywrapcp.Decision___str__(self) 2016 def __disown__(self): 2017 self.this.disown() 2018 _pywrapcp.disown_Decision(self) 2019 return weakref.proxy(self) 2020 2021# Register Decision in _pywrapcp: 2022_pywrapcp.Decision_swigregister(Decision) 2023class DecisionBuilder(BaseObject): 2024 r""" 2025 A DecisionBuilder is responsible for creating the search tree. The 2026 important method is Next(), which returns the next decision to execute. 2027 """ 2028 2029 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2030 2031 def __init__(self): 2032 if self.__class__ == DecisionBuilder: 2033 _self = None 2034 else: 2035 _self = self 2036 _pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, )) 2037 __swig_destroy__ = _pywrapcp.delete_DecisionBuilder 2038 2039 def NextWrapper(self, s): 2040 r""" 2041 This is the main method of the decision builder class. It must 2042 return a decision (an instance of the class Decision). If it 2043 returns nullptr, this means that the decision builder has finished 2044 its work. 2045 """ 2046 return _pywrapcp.DecisionBuilder_NextWrapper(self, s) 2047 2048 def DebugString(self): 2049 return _pywrapcp.DecisionBuilder_DebugString(self) 2050 2051 def __repr__(self): 2052 return _pywrapcp.DecisionBuilder___repr__(self) 2053 2054 def __str__(self): 2055 return _pywrapcp.DecisionBuilder___str__(self) 2056 def __disown__(self): 2057 self.this.disown() 2058 _pywrapcp.disown_DecisionBuilder(self) 2059 return weakref.proxy(self) 2060 2061# Register DecisionBuilder in _pywrapcp: 2062_pywrapcp.DecisionBuilder_swigregister(DecisionBuilder) 2063class Demon(BaseObject): 2064 r""" 2065 A Demon is the base element of a propagation queue. It is the main 2066 object responsible for implementing the actual propagation 2067 of the constraint and pruning the inconsistent values in the domains 2068 of the variables. The main concept is that demons are listeners that are 2069 attached to the variables and listen to their modifications. 2070 There are two methods: 2071 - Run() is the actual method called when the demon is processed. 2072 - priority() returns its priority. Standard priorities are slow, normal 2073 or fast. "immediate" is reserved for variables and is treated separately. 2074 """ 2075 2076 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2077 __repr__ = _swig_repr 2078 2079 def __init__(self): 2080 r""" 2081 This indicates the priority of a demon. Immediate demons are treated 2082 separately and corresponds to variables. 2083 """ 2084 if self.__class__ == Demon: 2085 _self = None 2086 else: 2087 _self = self 2088 _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, )) 2089 __swig_destroy__ = _pywrapcp.delete_Demon 2090 2091 def RunWrapper(self, s): 2092 r""" This is the main callback of the demon.""" 2093 return _pywrapcp.Demon_RunWrapper(self, s) 2094 2095 def Priority(self): 2096 r""" 2097 This method returns the priority of the demon. Usually a demon is 2098 fast, slow or normal. Immediate demons are reserved for internal 2099 use to maintain variables. 2100 """ 2101 return _pywrapcp.Demon_Priority(self) 2102 2103 def DebugString(self): 2104 return _pywrapcp.Demon_DebugString(self) 2105 2106 def Inhibit(self, s): 2107 r""" 2108 This method inhibits the demon in the search tree below the 2109 current position. 2110 """ 2111 return _pywrapcp.Demon_Inhibit(self, s) 2112 2113 def Desinhibit(self, s): 2114 r""" This method un-inhibits the demon that was previously inhibited.""" 2115 return _pywrapcp.Demon_Desinhibit(self, s) 2116 def __disown__(self): 2117 self.this.disown() 2118 _pywrapcp.disown_Demon(self) 2119 return weakref.proxy(self) 2120 2121# Register Demon in _pywrapcp: 2122_pywrapcp.Demon_swigregister(Demon) 2123class Constraint(PropagationBaseObject): 2124 r""" 2125 A constraint is the main modeling object. It provides two methods: 2126 - Post() is responsible for creating the demons and attaching them to 2127 immediate demons(). 2128 - InitialPropagate() is called once just after Post and performs 2129 the initial propagation. The subsequent propagations will be performed 2130 by the demons Posted during the post() method. 2131 """ 2132 2133 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2134 2135 def __init__(self, solver): 2136 if self.__class__ == Constraint: 2137 _self = None 2138 else: 2139 _self = self 2140 _pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver)) 2141 __swig_destroy__ = _pywrapcp.delete_Constraint 2142 2143 def Post(self): 2144 r""" 2145 This method is called when the constraint is processed by the 2146 solver. Its main usage is to attach demons to variables. 2147 """ 2148 return _pywrapcp.Constraint_Post(self) 2149 2150 def InitialPropagateWrapper(self): 2151 r""" 2152 This method performs the initial propagation of the 2153 constraint. It is called just after the post. 2154 """ 2155 return _pywrapcp.Constraint_InitialPropagateWrapper(self) 2156 2157 def DebugString(self): 2158 return _pywrapcp.Constraint_DebugString(self) 2159 2160 def Var(self): 2161 r""" 2162 Creates a Boolean variable representing the status of the constraint 2163 (false = constraint is violated, true = constraint is satisfied). It 2164 returns nullptr if the constraint does not support this API. 2165 """ 2166 return _pywrapcp.Constraint_Var(self) 2167 2168 def __repr__(self): 2169 return _pywrapcp.Constraint___repr__(self) 2170 2171 def __str__(self): 2172 return _pywrapcp.Constraint___str__(self) 2173 2174 def __add__(self, *args): 2175 return _pywrapcp.Constraint___add__(self, *args) 2176 2177 def __radd__(self, v): 2178 return _pywrapcp.Constraint___radd__(self, v) 2179 2180 def __sub__(self, *args): 2181 return _pywrapcp.Constraint___sub__(self, *args) 2182 2183 def __rsub__(self, v): 2184 return _pywrapcp.Constraint___rsub__(self, v) 2185 2186 def __mul__(self, *args): 2187 return _pywrapcp.Constraint___mul__(self, *args) 2188 2189 def __rmul__(self, v): 2190 return _pywrapcp.Constraint___rmul__(self, v) 2191 2192 def __floordiv__(self, v): 2193 return _pywrapcp.Constraint___floordiv__(self, v) 2194 2195 def __neg__(self): 2196 return _pywrapcp.Constraint___neg__(self) 2197 2198 def __abs__(self): 2199 return _pywrapcp.Constraint___abs__(self) 2200 2201 def Square(self): 2202 return _pywrapcp.Constraint_Square(self) 2203 2204 def __eq__(self, *args): 2205 return _pywrapcp.Constraint___eq__(self, *args) 2206 2207 def __ne__(self, *args): 2208 return _pywrapcp.Constraint___ne__(self, *args) 2209 2210 def __ge__(self, *args): 2211 return _pywrapcp.Constraint___ge__(self, *args) 2212 2213 def __gt__(self, *args): 2214 return _pywrapcp.Constraint___gt__(self, *args) 2215 2216 def __le__(self, *args): 2217 return _pywrapcp.Constraint___le__(self, *args) 2218 2219 def __lt__(self, *args): 2220 return _pywrapcp.Constraint___lt__(self, *args) 2221 2222 def MapTo(self, vars): 2223 return _pywrapcp.Constraint_MapTo(self, vars) 2224 2225 def IndexOf(self, *args): 2226 return _pywrapcp.Constraint_IndexOf(self, *args) 2227 def __disown__(self): 2228 self.this.disown() 2229 _pywrapcp.disown_Constraint(self) 2230 return weakref.proxy(self) 2231 2232# Register Constraint in _pywrapcp: 2233_pywrapcp.Constraint_swigregister(Constraint) 2234class SearchMonitor(BaseObject): 2235 r""" A search monitor is a simple set of callbacks to monitor all search events""" 2236 2237 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2238 kNoProgress = _pywrapcp.SearchMonitor_kNoProgress 2239 2240 def __init__(self, s): 2241 if self.__class__ == SearchMonitor: 2242 _self = None 2243 else: 2244 _self = self 2245 _pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s)) 2246 __swig_destroy__ = _pywrapcp.delete_SearchMonitor 2247 2248 def EnterSearch(self): 2249 r""" Beginning of the search.""" 2250 return _pywrapcp.SearchMonitor_EnterSearch(self) 2251 2252 def RestartSearch(self): 2253 r""" Restart the search.""" 2254 return _pywrapcp.SearchMonitor_RestartSearch(self) 2255 2256 def ExitSearch(self): 2257 r""" End of the search.""" 2258 return _pywrapcp.SearchMonitor_ExitSearch(self) 2259 2260 def BeginNextDecision(self, b): 2261 r""" Before calling DecisionBuilder::Next.""" 2262 return _pywrapcp.SearchMonitor_BeginNextDecision(self, b) 2263 2264 def EndNextDecision(self, b, d): 2265 r""" After calling DecisionBuilder::Next, along with the returned decision.""" 2266 return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d) 2267 2268 def ApplyDecision(self, d): 2269 r""" Before applying the decision.""" 2270 return _pywrapcp.SearchMonitor_ApplyDecision(self, d) 2271 2272 def RefuteDecision(self, d): 2273 r""" Before refuting the decision.""" 2274 return _pywrapcp.SearchMonitor_RefuteDecision(self, d) 2275 2276 def AfterDecision(self, d, apply): 2277 r""" 2278 Just after refuting or applying the decision, apply is true after Apply. 2279 This is called only if the Apply() or Refute() methods have not failed. 2280 """ 2281 return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply) 2282 2283 def BeginFail(self): 2284 r""" Just when the failure occurs.""" 2285 return _pywrapcp.SearchMonitor_BeginFail(self) 2286 2287 def EndFail(self): 2288 r""" After completing the backtrack.""" 2289 return _pywrapcp.SearchMonitor_EndFail(self) 2290 2291 def BeginInitialPropagation(self): 2292 r""" Before the initial propagation.""" 2293 return _pywrapcp.SearchMonitor_BeginInitialPropagation(self) 2294 2295 def EndInitialPropagation(self): 2296 r""" After the initial propagation.""" 2297 return _pywrapcp.SearchMonitor_EndInitialPropagation(self) 2298 2299 def AcceptSolution(self): 2300 r""" 2301 This method is called when a solution is found. It asserts whether the 2302 solution is valid. A value of false indicates that the solution 2303 should be discarded. 2304 """ 2305 return _pywrapcp.SearchMonitor_AcceptSolution(self) 2306 2307 def AtSolution(self): 2308 r""" 2309 This method is called when a valid solution is found. If the 2310 return value is true, then search will resume after. If the result 2311 is false, then search will stop there. 2312 """ 2313 return _pywrapcp.SearchMonitor_AtSolution(self) 2314 2315 def NoMoreSolutions(self): 2316 r""" When the search tree is finished.""" 2317 return _pywrapcp.SearchMonitor_NoMoreSolutions(self) 2318 2319 def LocalOptimum(self): 2320 r""" 2321 When a local optimum is reached. If 'true' is returned, the last solution 2322 is discarded and the search proceeds with the next one. 2323 """ 2324 return _pywrapcp.SearchMonitor_LocalOptimum(self) 2325 2326 def AcceptDelta(self, delta, deltadelta): 2327 2328 return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta) 2329 2330 def AcceptNeighbor(self): 2331 r""" After accepting a neighbor during local search.""" 2332 return _pywrapcp.SearchMonitor_AcceptNeighbor(self) 2333 2334 def ProgressPercent(self): 2335 r""" 2336 Returns a percentage representing the propress of the search before 2337 reaching limits. 2338 """ 2339 return _pywrapcp.SearchMonitor_ProgressPercent(self) 2340 2341 def solver(self): 2342 return _pywrapcp.SearchMonitor_solver(self) 2343 2344 def __repr__(self): 2345 return _pywrapcp.SearchMonitor___repr__(self) 2346 2347 def __str__(self): 2348 return _pywrapcp.SearchMonitor___str__(self) 2349 def __disown__(self): 2350 self.this.disown() 2351 _pywrapcp.disown_SearchMonitor(self) 2352 return weakref.proxy(self) 2353 2354# Register SearchMonitor in _pywrapcp: 2355_pywrapcp.SearchMonitor_swigregister(SearchMonitor) 2356class IntExpr(PropagationBaseObject): 2357 r""" 2358 The class IntExpr is the base of all integer expressions in 2359 constraint programming. 2360 It contains the basic protocol for an expression: 2361 - setting and modifying its bound 2362 - querying if it is bound 2363 - listening to events modifying its bounds 2364 - casting it into a variable (instance of IntVar) 2365 """ 2366 2367 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2368 2369 def __init__(self, *args, **kwargs): 2370 raise AttributeError("No constructor defined - class is abstract") 2371 2372 def Min(self): 2373 return _pywrapcp.IntExpr_Min(self) 2374 2375 def SetMin(self, m): 2376 return _pywrapcp.IntExpr_SetMin(self, m) 2377 2378 def Max(self): 2379 return _pywrapcp.IntExpr_Max(self) 2380 2381 def SetMax(self, m): 2382 return _pywrapcp.IntExpr_SetMax(self, m) 2383 2384 def SetRange(self, l, u): 2385 r""" This method sets both the min and the max of the expression.""" 2386 return _pywrapcp.IntExpr_SetRange(self, l, u) 2387 2388 def SetValue(self, v): 2389 r""" This method sets the value of the expression.""" 2390 return _pywrapcp.IntExpr_SetValue(self, v) 2391 2392 def Bound(self): 2393 r""" Returns true if the min and the max of the expression are equal.""" 2394 return _pywrapcp.IntExpr_Bound(self) 2395 2396 def IsVar(self): 2397 r""" Returns true if the expression is indeed a variable.""" 2398 return _pywrapcp.IntExpr_IsVar(self) 2399 2400 def Var(self): 2401 r""" Creates a variable from the expression.""" 2402 return _pywrapcp.IntExpr_Var(self) 2403 2404 def VarWithName(self, name): 2405 r""" 2406 Creates a variable from the expression and set the name of the 2407 resulting var. If the expression is already a variable, then it 2408 will set the name of the expression, possibly overwriting it. 2409 This is just a shortcut to Var() followed by set_name(). 2410 """ 2411 return _pywrapcp.IntExpr_VarWithName(self, name) 2412 2413 def WhenRange(self, *args): 2414 r""" 2415 *Overload 1:* 2416 Attach a demon that will watch the min or the max of the expression. 2417 2418 | 2419 2420 *Overload 2:* 2421 Attach a demon that will watch the min or the max of the expression. 2422 """ 2423 return _pywrapcp.IntExpr_WhenRange(self, *args) 2424 2425 def __repr__(self): 2426 return _pywrapcp.IntExpr___repr__(self) 2427 2428 def __str__(self): 2429 return _pywrapcp.IntExpr___str__(self) 2430 2431 def __add__(self, *args): 2432 return _pywrapcp.IntExpr___add__(self, *args) 2433 2434 def __radd__(self, v): 2435 return _pywrapcp.IntExpr___radd__(self, v) 2436 2437 def __sub__(self, *args): 2438 return _pywrapcp.IntExpr___sub__(self, *args) 2439 2440 def __rsub__(self, v): 2441 return _pywrapcp.IntExpr___rsub__(self, v) 2442 2443 def __mul__(self, *args): 2444 return _pywrapcp.IntExpr___mul__(self, *args) 2445 2446 def __rmul__(self, v): 2447 return _pywrapcp.IntExpr___rmul__(self, v) 2448 2449 def __floordiv__(self, *args): 2450 return _pywrapcp.IntExpr___floordiv__(self, *args) 2451 2452 def __mod__(self, *args): 2453 return _pywrapcp.IntExpr___mod__(self, *args) 2454 2455 def __neg__(self): 2456 return _pywrapcp.IntExpr___neg__(self) 2457 2458 def __abs__(self): 2459 return _pywrapcp.IntExpr___abs__(self) 2460 2461 def Square(self): 2462 return _pywrapcp.IntExpr_Square(self) 2463 2464 def __eq__(self, *args): 2465 return _pywrapcp.IntExpr___eq__(self, *args) 2466 2467 def __ne__(self, *args): 2468 return _pywrapcp.IntExpr___ne__(self, *args) 2469 2470 def __ge__(self, *args): 2471 return _pywrapcp.IntExpr___ge__(self, *args) 2472 2473 def __gt__(self, *args): 2474 return _pywrapcp.IntExpr___gt__(self, *args) 2475 2476 def __le__(self, *args): 2477 return _pywrapcp.IntExpr___le__(self, *args) 2478 2479 def __lt__(self, *args): 2480 return _pywrapcp.IntExpr___lt__(self, *args) 2481 2482 def MapTo(self, vars): 2483 return _pywrapcp.IntExpr_MapTo(self, vars) 2484 2485 def IndexOf(self, *args): 2486 return _pywrapcp.IntExpr_IndexOf(self, *args) 2487 2488 def IsMember(self, values): 2489 return _pywrapcp.IntExpr_IsMember(self, values) 2490 2491 def Member(self, values): 2492 return _pywrapcp.IntExpr_Member(self, values) 2493 2494 def NotMember(self, starts, ends): 2495 return _pywrapcp.IntExpr_NotMember(self, starts, ends) 2496 2497# Register IntExpr in _pywrapcp: 2498_pywrapcp.IntExpr_swigregister(IntExpr) 2499class IntVarIterator(BaseObject): 2500 r""" 2501 The class Iterator has two direct subclasses. HoleIterators 2502 iterates over all holes, that is value removed between the 2503 current min and max of the variable since the last time the 2504 variable was processed in the queue. DomainIterators iterates 2505 over all elements of the variable domain. Both iterators are not 2506 robust to domain changes. Hole iterators can also report values outside 2507 the current min and max of the variable. 2508 HoleIterators should only be called from a demon attached to the 2509 variable that has created this iterator. 2510 IntVar* current_var; 2511 std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false)); 2512 for (const int64_t hole : InitAndGetValues(it)) { 2513 use the hole 2514 } 2515 """ 2516 2517 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2518 2519 def __init__(self, *args, **kwargs): 2520 raise AttributeError("No constructor defined - class is abstract") 2521 __repr__ = _swig_repr 2522 2523 def Init(self): 2524 r""" This method must be called before each loop.""" 2525 return _pywrapcp.IntVarIterator_Init(self) 2526 2527 def Ok(self): 2528 r""" This method indicates if we can call Value() or not.""" 2529 return _pywrapcp.IntVarIterator_Ok(self) 2530 2531 def Value(self): 2532 r""" This method returns the current value of the iterator.""" 2533 return _pywrapcp.IntVarIterator_Value(self) 2534 2535 def Next(self): 2536 r""" This method moves the iterator to the next value.""" 2537 return _pywrapcp.IntVarIterator_Next(self) 2538 2539 def DebugString(self): 2540 r""" Pretty Print.""" 2541 return _pywrapcp.IntVarIterator_DebugString(self) 2542 2543 def __iter__(self): 2544 self.Init() 2545 return self 2546 2547 def next(self): 2548 if self.Ok(): 2549 result = self.Value() 2550 self.Next() 2551 return result 2552 else: 2553 raise StopIteration() 2554 2555 def __next__(self): 2556 return self.next() 2557 2558 2559# Register IntVarIterator in _pywrapcp: 2560_pywrapcp.IntVarIterator_swigregister(IntVarIterator) 2561class IntVar(IntExpr): 2562 r""" 2563 The class IntVar is a subset of IntExpr. In addition to the 2564 IntExpr protocol, it offers persistence, removing values from the domains, 2565 and a finer model for events. 2566 """ 2567 2568 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2569 2570 def __init__(self, *args, **kwargs): 2571 raise AttributeError("No constructor defined - class is abstract") 2572 2573 def IsVar(self): 2574 return _pywrapcp.IntVar_IsVar(self) 2575 2576 def Var(self): 2577 return _pywrapcp.IntVar_Var(self) 2578 2579 def Value(self): 2580 r""" 2581 This method returns the value of the variable. This method checks 2582 before that the variable is bound. 2583 """ 2584 return _pywrapcp.IntVar_Value(self) 2585 2586 def RemoveValue(self, v): 2587 r""" This method removes the value 'v' from the domain of the variable.""" 2588 return _pywrapcp.IntVar_RemoveValue(self, v) 2589 2590 def RemoveInterval(self, l, u): 2591 r""" 2592 This method removes the interval 'l' .. 'u' from the domain of 2593 the variable. It assumes that 'l' <= 'u'. 2594 """ 2595 return _pywrapcp.IntVar_RemoveInterval(self, l, u) 2596 2597 def RemoveValues(self, values): 2598 r""" This method remove the values from the domain of the variable.""" 2599 return _pywrapcp.IntVar_RemoveValues(self, values) 2600 2601 def SetValues(self, values): 2602 r""" This method intersects the current domain with the values in the array.""" 2603 return _pywrapcp.IntVar_SetValues(self, values) 2604 2605 def WhenBound(self, *args): 2606 r""" 2607 *Overload 1:* 2608 This method attaches a demon that will be awakened when the 2609 variable is bound. 2610 2611 | 2612 2613 *Overload 2:* 2614 This method attaches a closure that will be awakened when the 2615 variable is bound. 2616 """ 2617 return _pywrapcp.IntVar_WhenBound(self, *args) 2618 2619 def WhenDomain(self, *args): 2620 r""" 2621 *Overload 1:* 2622 This method attaches a demon that will watch any domain 2623 modification of the domain of the variable. 2624 2625 | 2626 2627 *Overload 2:* 2628 This method attaches a closure that will watch any domain 2629 modification of the domain of the variable. 2630 """ 2631 return _pywrapcp.IntVar_WhenDomain(self, *args) 2632 2633 def Size(self): 2634 r""" This method returns the number of values in the domain of the variable.""" 2635 return _pywrapcp.IntVar_Size(self) 2636 2637 def Contains(self, v): 2638 r""" 2639 This method returns whether the value 'v' is in the domain of the 2640 variable. 2641 """ 2642 return _pywrapcp.IntVar_Contains(self, v) 2643 2644 def HoleIteratorAux(self, reversible): 2645 r""" 2646 Creates a hole iterator. When 'reversible' is false, the returned 2647 object is created on the normal C++ heap and the solver does NOT 2648 take ownership of the object. 2649 """ 2650 return _pywrapcp.IntVar_HoleIteratorAux(self, reversible) 2651 2652 def DomainIteratorAux(self, reversible): 2653 r""" 2654 Creates a domain iterator. When 'reversible' is false, the 2655 returned object is created on the normal C++ heap and the solver 2656 does NOT take ownership of the object. 2657 """ 2658 return _pywrapcp.IntVar_DomainIteratorAux(self, reversible) 2659 2660 def OldMin(self): 2661 r""" Returns the previous min.""" 2662 return _pywrapcp.IntVar_OldMin(self) 2663 2664 def OldMax(self): 2665 r""" Returns the previous max.""" 2666 return _pywrapcp.IntVar_OldMax(self) 2667 2668 def __repr__(self): 2669 return _pywrapcp.IntVar___repr__(self) 2670 2671 def __str__(self): 2672 return _pywrapcp.IntVar___str__(self) 2673 2674 def DomainIterator(self): 2675 return iter(self.DomainIteratorAux(False)) 2676 2677 def HoleIterator(self): 2678 return iter(self.HoleIteratorAux(False)) 2679 2680 2681# Register IntVar in _pywrapcp: 2682_pywrapcp.IntVar_swigregister(IntVar) 2683class SolutionCollector(SearchMonitor): 2684 r""" 2685 This class is the root class of all solution collectors. 2686 It implements a basic query API to be used independently 2687 of the collector used. 2688 """ 2689 2690 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2691 2692 def __init__(self, *args, **kwargs): 2693 raise AttributeError("No constructor defined") 2694 __repr__ = _swig_repr 2695 2696 def DebugString(self): 2697 return _pywrapcp.SolutionCollector_DebugString(self) 2698 2699 def Add(self, *args): 2700 return _pywrapcp.SolutionCollector_Add(self, *args) 2701 2702 def AddObjective(self, objective): 2703 return _pywrapcp.SolutionCollector_AddObjective(self, objective) 2704 2705 def EnterSearch(self): 2706 r""" Beginning of the search.""" 2707 return _pywrapcp.SolutionCollector_EnterSearch(self) 2708 2709 def SolutionCount(self): 2710 r""" Returns how many solutions were stored during the search.""" 2711 return _pywrapcp.SolutionCollector_SolutionCount(self) 2712 2713 def Solution(self, n): 2714 r""" Returns the nth solution.""" 2715 return _pywrapcp.SolutionCollector_Solution(self, n) 2716 2717 def WallTime(self, n): 2718 r""" Returns the wall time in ms for the nth solution.""" 2719 return _pywrapcp.SolutionCollector_WallTime(self, n) 2720 2721 def Branches(self, n): 2722 r""" Returns the number of branches when the nth solution was found.""" 2723 return _pywrapcp.SolutionCollector_Branches(self, n) 2724 2725 def Failures(self, n): 2726 r""" 2727 Returns the number of failures encountered at the time of the nth 2728 solution. 2729 """ 2730 return _pywrapcp.SolutionCollector_Failures(self, n) 2731 2732 def ObjectiveValue(self, n): 2733 r""" Returns the objective value of the nth solution.""" 2734 return _pywrapcp.SolutionCollector_ObjectiveValue(self, n) 2735 2736 def Value(self, n, var): 2737 r""" This is a shortcut to get the Value of 'var' in the nth solution.""" 2738 return _pywrapcp.SolutionCollector_Value(self, n, var) 2739 2740 def StartValue(self, n, var): 2741 r""" This is a shortcut to get the StartValue of 'var' in the nth solution.""" 2742 return _pywrapcp.SolutionCollector_StartValue(self, n, var) 2743 2744 def EndValue(self, n, var): 2745 r""" This is a shortcut to get the EndValue of 'var' in the nth solution.""" 2746 return _pywrapcp.SolutionCollector_EndValue(self, n, var) 2747 2748 def DurationValue(self, n, var): 2749 r""" This is a shortcut to get the DurationValue of 'var' in the nth solution.""" 2750 return _pywrapcp.SolutionCollector_DurationValue(self, n, var) 2751 2752 def PerformedValue(self, n, var): 2753 r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution.""" 2754 return _pywrapcp.SolutionCollector_PerformedValue(self, n, var) 2755 2756 def ForwardSequence(self, n, var): 2757 r""" 2758 This is a shortcut to get the ForwardSequence of 'var' in the 2759 nth solution. The forward sequence is the list of ranked interval 2760 variables starting from the start of the sequence. 2761 """ 2762 return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var) 2763 2764 def BackwardSequence(self, n, var): 2765 r""" 2766 This is a shortcut to get the BackwardSequence of 'var' in the 2767 nth solution. The backward sequence is the list of ranked interval 2768 variables starting from the end of the sequence. 2769 """ 2770 return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var) 2771 2772 def Unperformed(self, n, var): 2773 r""" 2774 This is a shortcut to get the list of unperformed of 'var' in the 2775 nth solution. 2776 """ 2777 return _pywrapcp.SolutionCollector_Unperformed(self, n, var) 2778 2779# Register SolutionCollector in _pywrapcp: 2780_pywrapcp.SolutionCollector_swigregister(SolutionCollector) 2781class OptimizeVar(object): 2782 r""" 2783 This class encapsulates an objective. It requires the direction 2784 (minimize or maximize), the variable to optimize, and the 2785 improvement step. 2786 """ 2787 2788 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2789 2790 def __init__(self, *args, **kwargs): 2791 raise AttributeError("No constructor defined") 2792 __repr__ = _swig_repr 2793 2794 def Best(self): 2795 r""" Returns the best value found during search.""" 2796 return _pywrapcp.OptimizeVar_Best(self) 2797 2798 def AcceptDelta(self, delta, deltadelta): 2799 r""" Internal methods.""" 2800 return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta) 2801 2802 def BeginNextDecision(self, db): 2803 return _pywrapcp.OptimizeVar_BeginNextDecision(self, db) 2804 2805 def RefuteDecision(self, d): 2806 return _pywrapcp.OptimizeVar_RefuteDecision(self, d) 2807 2808 def AtSolution(self): 2809 return _pywrapcp.OptimizeVar_AtSolution(self) 2810 2811 def AcceptSolution(self): 2812 return _pywrapcp.OptimizeVar_AcceptSolution(self) 2813 2814 def DebugString(self): 2815 return _pywrapcp.OptimizeVar_DebugString(self) 2816 __swig_destroy__ = _pywrapcp.delete_OptimizeVar 2817 2818# Register OptimizeVar in _pywrapcp: 2819_pywrapcp.OptimizeVar_swigregister(OptimizeVar) 2820class SearchLimit(SearchMonitor): 2821 r""" Base class of all search limits.""" 2822 2823 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2824 2825 def __init__(self, *args, **kwargs): 2826 raise AttributeError("No constructor defined - class is abstract") 2827 __repr__ = _swig_repr 2828 __swig_destroy__ = _pywrapcp.delete_SearchLimit 2829 2830 def Crossed(self): 2831 r""" Returns true if the limit has been crossed.""" 2832 return _pywrapcp.SearchLimit_Crossed(self) 2833 2834 def Check(self): 2835 r""" 2836 This method is called to check the status of the limit. A return 2837 value of true indicates that we have indeed crossed the limit. In 2838 that case, this method will not be called again and the remaining 2839 search will be discarded. 2840 """ 2841 return _pywrapcp.SearchLimit_Check(self) 2842 2843 def Init(self): 2844 r""" This method is called when the search limit is initialized.""" 2845 return _pywrapcp.SearchLimit_Init(self) 2846 2847 def EnterSearch(self): 2848 r""" Internal methods.""" 2849 return _pywrapcp.SearchLimit_EnterSearch(self) 2850 2851 def BeginNextDecision(self, b): 2852 return _pywrapcp.SearchLimit_BeginNextDecision(self, b) 2853 2854 def RefuteDecision(self, d): 2855 return _pywrapcp.SearchLimit_RefuteDecision(self, d) 2856 2857 def DebugString(self): 2858 return _pywrapcp.SearchLimit_DebugString(self) 2859 2860# Register SearchLimit in _pywrapcp: 2861_pywrapcp.SearchLimit_swigregister(SearchLimit) 2862class IntervalVar(PropagationBaseObject): 2863 r""" 2864 Interval variables are often used in scheduling. The main characteristics 2865 of an IntervalVar are the start position, duration, and end 2866 date. All these characteristics can be queried and set, and demons can 2867 be posted on their modifications. 2868 2869 An important aspect is optionality: an IntervalVar can be performed or not. 2870 If unperformed, then it simply does not exist, and its characteristics 2871 cannot be accessed any more. An interval var is automatically marked 2872 as unperformed when it is not consistent anymore (start greater 2873 than end, duration < 0...) 2874 """ 2875 2876 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2877 2878 def __init__(self, *args, **kwargs): 2879 raise AttributeError("No constructor defined - class is abstract") 2880 2881 def StartMin(self): 2882 r""" 2883 These methods query, set, and watch the start position of the 2884 interval var. 2885 """ 2886 return _pywrapcp.IntervalVar_StartMin(self) 2887 2888 def StartMax(self): 2889 return _pywrapcp.IntervalVar_StartMax(self) 2890 2891 def SetStartMin(self, m): 2892 return _pywrapcp.IntervalVar_SetStartMin(self, m) 2893 2894 def SetStartMax(self, m): 2895 return _pywrapcp.IntervalVar_SetStartMax(self, m) 2896 2897 def SetStartRange(self, mi, ma): 2898 return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma) 2899 2900 def OldStartMin(self): 2901 return _pywrapcp.IntervalVar_OldStartMin(self) 2902 2903 def OldStartMax(self): 2904 return _pywrapcp.IntervalVar_OldStartMax(self) 2905 2906 def WhenStartRange(self, *args): 2907 return _pywrapcp.IntervalVar_WhenStartRange(self, *args) 2908 2909 def WhenStartBound(self, *args): 2910 return _pywrapcp.IntervalVar_WhenStartBound(self, *args) 2911 2912 def DurationMin(self): 2913 r""" These methods query, set, and watch the duration of the interval var.""" 2914 return _pywrapcp.IntervalVar_DurationMin(self) 2915 2916 def DurationMax(self): 2917 return _pywrapcp.IntervalVar_DurationMax(self) 2918 2919 def SetDurationMin(self, m): 2920 return _pywrapcp.IntervalVar_SetDurationMin(self, m) 2921 2922 def SetDurationMax(self, m): 2923 return _pywrapcp.IntervalVar_SetDurationMax(self, m) 2924 2925 def SetDurationRange(self, mi, ma): 2926 return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma) 2927 2928 def OldDurationMin(self): 2929 return _pywrapcp.IntervalVar_OldDurationMin(self) 2930 2931 def OldDurationMax(self): 2932 return _pywrapcp.IntervalVar_OldDurationMax(self) 2933 2934 def WhenDurationRange(self, *args): 2935 return _pywrapcp.IntervalVar_WhenDurationRange(self, *args) 2936 2937 def WhenDurationBound(self, *args): 2938 return _pywrapcp.IntervalVar_WhenDurationBound(self, *args) 2939 2940 def EndMin(self): 2941 r""" These methods query, set, and watch the end position of the interval var.""" 2942 return _pywrapcp.IntervalVar_EndMin(self) 2943 2944 def EndMax(self): 2945 return _pywrapcp.IntervalVar_EndMax(self) 2946 2947 def SetEndMin(self, m): 2948 return _pywrapcp.IntervalVar_SetEndMin(self, m) 2949 2950 def SetEndMax(self, m): 2951 return _pywrapcp.IntervalVar_SetEndMax(self, m) 2952 2953 def SetEndRange(self, mi, ma): 2954 return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma) 2955 2956 def OldEndMin(self): 2957 return _pywrapcp.IntervalVar_OldEndMin(self) 2958 2959 def OldEndMax(self): 2960 return _pywrapcp.IntervalVar_OldEndMax(self) 2961 2962 def WhenEndRange(self, *args): 2963 return _pywrapcp.IntervalVar_WhenEndRange(self, *args) 2964 2965 def WhenEndBound(self, *args): 2966 return _pywrapcp.IntervalVar_WhenEndBound(self, *args) 2967 2968 def MustBePerformed(self): 2969 r""" 2970 These methods query, set, and watch the performed status of the 2971 interval var. 2972 """ 2973 return _pywrapcp.IntervalVar_MustBePerformed(self) 2974 2975 def MayBePerformed(self): 2976 return _pywrapcp.IntervalVar_MayBePerformed(self) 2977 2978 def CannotBePerformed(self): 2979 return _pywrapcp.IntervalVar_CannotBePerformed(self) 2980 2981 def IsPerformedBound(self): 2982 return _pywrapcp.IntervalVar_IsPerformedBound(self) 2983 2984 def SetPerformed(self, val): 2985 return _pywrapcp.IntervalVar_SetPerformed(self, val) 2986 2987 def WasPerformedBound(self): 2988 return _pywrapcp.IntervalVar_WasPerformedBound(self) 2989 2990 def WhenPerformedBound(self, *args): 2991 return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args) 2992 2993 def WhenAnything(self, *args): 2994 r""" 2995 *Overload 1:* 2996 Attaches a demon awakened when anything about this interval changes. 2997 2998 | 2999 3000 *Overload 2:* 3001 Attaches a closure awakened when anything about this interval changes. 3002 """ 3003 return _pywrapcp.IntervalVar_WhenAnything(self, *args) 3004 3005 def StartExpr(self): 3006 r""" 3007 These methods create expressions encapsulating the start, end 3008 and duration of the interval var. Please note that these must not 3009 be used if the interval var is unperformed. 3010 """ 3011 return _pywrapcp.IntervalVar_StartExpr(self) 3012 3013 def DurationExpr(self): 3014 return _pywrapcp.IntervalVar_DurationExpr(self) 3015 3016 def EndExpr(self): 3017 return _pywrapcp.IntervalVar_EndExpr(self) 3018 3019 def PerformedExpr(self): 3020 return _pywrapcp.IntervalVar_PerformedExpr(self) 3021 3022 def SafeStartExpr(self, unperformed_value): 3023 r""" 3024 These methods create expressions encapsulating the start, end 3025 and duration of the interval var. If the interval var is 3026 unperformed, they will return the unperformed_value. 3027 """ 3028 return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value) 3029 3030 def SafeDurationExpr(self, unperformed_value): 3031 return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value) 3032 3033 def SafeEndExpr(self, unperformed_value): 3034 return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value) 3035 3036 def EndsAfterEnd(self, other): 3037 return _pywrapcp.IntervalVar_EndsAfterEnd(self, other) 3038 3039 def EndsAfterEndWithDelay(self, other, delay): 3040 return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay) 3041 3042 def EndsAfterStart(self, other): 3043 return _pywrapcp.IntervalVar_EndsAfterStart(self, other) 3044 3045 def EndsAfterStartWithDelay(self, other, delay): 3046 return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay) 3047 3048 def EndsAtEnd(self, other): 3049 return _pywrapcp.IntervalVar_EndsAtEnd(self, other) 3050 3051 def EndsAtEndWithDelay(self, other, delay): 3052 return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay) 3053 3054 def EndsAtStart(self, other): 3055 return _pywrapcp.IntervalVar_EndsAtStart(self, other) 3056 3057 def EndsAtStartWithDelay(self, other, delay): 3058 return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay) 3059 3060 def StartsAfterEnd(self, other): 3061 return _pywrapcp.IntervalVar_StartsAfterEnd(self, other) 3062 3063 def StartsAfterEndWithDelay(self, other, delay): 3064 return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay) 3065 3066 def StartsAfterStart(self, other): 3067 return _pywrapcp.IntervalVar_StartsAfterStart(self, other) 3068 3069 def StartsAfterStartWithDelay(self, other, delay): 3070 return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay) 3071 3072 def StartsAtEnd(self, other): 3073 return _pywrapcp.IntervalVar_StartsAtEnd(self, other) 3074 3075 def StartsAtEndWithDelay(self, other, delay): 3076 return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay) 3077 3078 def StartsAtStart(self, other): 3079 return _pywrapcp.IntervalVar_StartsAtStart(self, other) 3080 3081 def StartsAtStartWithDelay(self, other, delay): 3082 return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay) 3083 3084 def StaysInSync(self, other): 3085 return _pywrapcp.IntervalVar_StaysInSync(self, other) 3086 3087 def StaysInSyncWithDelay(self, other, delay): 3088 return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay) 3089 3090 def EndsAfter(self, date): 3091 return _pywrapcp.IntervalVar_EndsAfter(self, date) 3092 3093 def EndsAt(self, date): 3094 return _pywrapcp.IntervalVar_EndsAt(self, date) 3095 3096 def EndsBefore(self, date): 3097 return _pywrapcp.IntervalVar_EndsBefore(self, date) 3098 3099 def StartsAfter(self, date): 3100 return _pywrapcp.IntervalVar_StartsAfter(self, date) 3101 3102 def StartsAt(self, date): 3103 return _pywrapcp.IntervalVar_StartsAt(self, date) 3104 3105 def StartsBefore(self, date): 3106 return _pywrapcp.IntervalVar_StartsBefore(self, date) 3107 3108 def CrossesDate(self, date): 3109 return _pywrapcp.IntervalVar_CrossesDate(self, date) 3110 3111 def AvoidsDate(self, date): 3112 return _pywrapcp.IntervalVar_AvoidsDate(self, date) 3113 3114 def __repr__(self): 3115 return _pywrapcp.IntervalVar___repr__(self) 3116 3117 def __str__(self): 3118 return _pywrapcp.IntervalVar___str__(self) 3119 3120# Register IntervalVar in _pywrapcp: 3121_pywrapcp.IntervalVar_swigregister(IntervalVar) 3122class SequenceVar(PropagationBaseObject): 3123 r""" 3124 A sequence variable is a variable whose domain is a set of possible 3125 orderings of the interval variables. It allows ordering of tasks. It 3126 has two sets of methods: ComputePossibleFirstsAndLasts(), which 3127 returns the list of interval variables that can be ranked first or 3128 last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be 3129 used to create the search decision. 3130 """ 3131 3132 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3133 3134 def __init__(self, *args, **kwargs): 3135 raise AttributeError("No constructor defined") 3136 3137 def DebugString(self): 3138 return _pywrapcp.SequenceVar_DebugString(self) 3139 3140 def RankFirst(self, index): 3141 r""" 3142 Ranks the index_th interval var first of all unranked interval 3143 vars. After that, it will no longer be considered ranked. 3144 """ 3145 return _pywrapcp.SequenceVar_RankFirst(self, index) 3146 3147 def RankNotFirst(self, index): 3148 r""" 3149 Indicates that the index_th interval var will not be ranked first 3150 of all currently unranked interval vars. 3151 """ 3152 return _pywrapcp.SequenceVar_RankNotFirst(self, index) 3153 3154 def RankLast(self, index): 3155 r""" 3156 Ranks the index_th interval var first of all unranked interval 3157 vars. After that, it will no longer be considered ranked. 3158 """ 3159 return _pywrapcp.SequenceVar_RankLast(self, index) 3160 3161 def RankNotLast(self, index): 3162 r""" 3163 Indicates that the index_th interval var will not be ranked first 3164 of all currently unranked interval vars. 3165 """ 3166 return _pywrapcp.SequenceVar_RankNotLast(self, index) 3167 3168 def Interval(self, index): 3169 r""" Returns the index_th interval of the sequence.""" 3170 return _pywrapcp.SequenceVar_Interval(self, index) 3171 3172 def Next(self, index): 3173 r""" Returns the next of the index_th interval of the sequence.""" 3174 return _pywrapcp.SequenceVar_Next(self, index) 3175 3176 def Size(self): 3177 r""" Returns the number of interval vars in the sequence.""" 3178 return _pywrapcp.SequenceVar_Size(self) 3179 3180 def __repr__(self): 3181 return _pywrapcp.SequenceVar___repr__(self) 3182 3183 def __str__(self): 3184 return _pywrapcp.SequenceVar___str__(self) 3185 3186# Register SequenceVar in _pywrapcp: 3187_pywrapcp.SequenceVar_swigregister(SequenceVar) 3188class AssignmentElement(object): 3189 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3190 3191 def __init__(self, *args, **kwargs): 3192 raise AttributeError("No constructor defined") 3193 __repr__ = _swig_repr 3194 3195 def Activate(self): 3196 return _pywrapcp.AssignmentElement_Activate(self) 3197 3198 def Deactivate(self): 3199 return _pywrapcp.AssignmentElement_Deactivate(self) 3200 3201 def Activated(self): 3202 return _pywrapcp.AssignmentElement_Activated(self) 3203 __swig_destroy__ = _pywrapcp.delete_AssignmentElement 3204 3205# Register AssignmentElement in _pywrapcp: 3206_pywrapcp.AssignmentElement_swigregister(AssignmentElement) 3207class IntVarElement(AssignmentElement): 3208 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3209 3210 def __init__(self, *args, **kwargs): 3211 raise AttributeError("No constructor defined") 3212 __repr__ = _swig_repr 3213 3214 def Var(self): 3215 return _pywrapcp.IntVarElement_Var(self) 3216 3217 def Min(self): 3218 return _pywrapcp.IntVarElement_Min(self) 3219 3220 def SetMin(self, m): 3221 return _pywrapcp.IntVarElement_SetMin(self, m) 3222 3223 def Max(self): 3224 return _pywrapcp.IntVarElement_Max(self) 3225 3226 def SetMax(self, m): 3227 return _pywrapcp.IntVarElement_SetMax(self, m) 3228 3229 def Value(self): 3230 return _pywrapcp.IntVarElement_Value(self) 3231 3232 def Bound(self): 3233 return _pywrapcp.IntVarElement_Bound(self) 3234 3235 def SetRange(self, l, u): 3236 return _pywrapcp.IntVarElement_SetRange(self, l, u) 3237 3238 def SetValue(self, v): 3239 return _pywrapcp.IntVarElement_SetValue(self, v) 3240 3241 def __eq__(self, element): 3242 return _pywrapcp.IntVarElement___eq__(self, element) 3243 3244 def __ne__(self, element): 3245 return _pywrapcp.IntVarElement___ne__(self, element) 3246 __swig_destroy__ = _pywrapcp.delete_IntVarElement 3247 3248# Register IntVarElement in _pywrapcp: 3249_pywrapcp.IntVarElement_swigregister(IntVarElement) 3250class IntervalVarElement(AssignmentElement): 3251 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3252 3253 def __init__(self, *args, **kwargs): 3254 raise AttributeError("No constructor defined") 3255 __repr__ = _swig_repr 3256 3257 def Var(self): 3258 return _pywrapcp.IntervalVarElement_Var(self) 3259 3260 def StartMin(self): 3261 return _pywrapcp.IntervalVarElement_StartMin(self) 3262 3263 def StartMax(self): 3264 return _pywrapcp.IntervalVarElement_StartMax(self) 3265 3266 def StartValue(self): 3267 return _pywrapcp.IntervalVarElement_StartValue(self) 3268 3269 def DurationMin(self): 3270 return _pywrapcp.IntervalVarElement_DurationMin(self) 3271 3272 def DurationMax(self): 3273 return _pywrapcp.IntervalVarElement_DurationMax(self) 3274 3275 def DurationValue(self): 3276 return _pywrapcp.IntervalVarElement_DurationValue(self) 3277 3278 def EndMin(self): 3279 return _pywrapcp.IntervalVarElement_EndMin(self) 3280 3281 def EndMax(self): 3282 return _pywrapcp.IntervalVarElement_EndMax(self) 3283 3284 def EndValue(self): 3285 return _pywrapcp.IntervalVarElement_EndValue(self) 3286 3287 def PerformedMin(self): 3288 return _pywrapcp.IntervalVarElement_PerformedMin(self) 3289 3290 def PerformedMax(self): 3291 return _pywrapcp.IntervalVarElement_PerformedMax(self) 3292 3293 def PerformedValue(self): 3294 return _pywrapcp.IntervalVarElement_PerformedValue(self) 3295 3296 def SetStartMin(self, m): 3297 return _pywrapcp.IntervalVarElement_SetStartMin(self, m) 3298 3299 def SetStartMax(self, m): 3300 return _pywrapcp.IntervalVarElement_SetStartMax(self, m) 3301 3302 def SetStartRange(self, mi, ma): 3303 return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma) 3304 3305 def SetStartValue(self, v): 3306 return _pywrapcp.IntervalVarElement_SetStartValue(self, v) 3307 3308 def SetDurationMin(self, m): 3309 return _pywrapcp.IntervalVarElement_SetDurationMin(self, m) 3310 3311 def SetDurationMax(self, m): 3312 return _pywrapcp.IntervalVarElement_SetDurationMax(self, m) 3313 3314 def SetDurationRange(self, mi, ma): 3315 return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma) 3316 3317 def SetDurationValue(self, v): 3318 return _pywrapcp.IntervalVarElement_SetDurationValue(self, v) 3319 3320 def SetEndMin(self, m): 3321 return _pywrapcp.IntervalVarElement_SetEndMin(self, m) 3322 3323 def SetEndMax(self, m): 3324 return _pywrapcp.IntervalVarElement_SetEndMax(self, m) 3325 3326 def SetEndRange(self, mi, ma): 3327 return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma) 3328 3329 def SetEndValue(self, v): 3330 return _pywrapcp.IntervalVarElement_SetEndValue(self, v) 3331 3332 def SetPerformedMin(self, m): 3333 return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m) 3334 3335 def SetPerformedMax(self, m): 3336 return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m) 3337 3338 def SetPerformedRange(self, mi, ma): 3339 return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma) 3340 3341 def SetPerformedValue(self, v): 3342 return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v) 3343 3344 def __eq__(self, element): 3345 return _pywrapcp.IntervalVarElement___eq__(self, element) 3346 3347 def __ne__(self, element): 3348 return _pywrapcp.IntervalVarElement___ne__(self, element) 3349 __swig_destroy__ = _pywrapcp.delete_IntervalVarElement 3350 3351# Register IntervalVarElement in _pywrapcp: 3352_pywrapcp.IntervalVarElement_swigregister(IntervalVarElement) 3353class SequenceVarElement(AssignmentElement): 3354 r""" 3355 The SequenceVarElement stores a partial representation of ranked 3356 interval variables in the underlying sequence variable. 3357 This representation consists of three vectors: 3358 - the forward sequence. That is the list of interval variables 3359 ranked first in the sequence. The first element of the backward 3360 sequence is the first interval in the sequence variable. 3361 - the backward sequence. That is the list of interval variables 3362 ranked last in the sequence. The first element of the backward 3363 sequence is the last interval in the sequence variable. 3364 - The list of unperformed interval variables. 3365 Furthermore, if all performed variables are ranked, then by 3366 convention, the forward_sequence will contain all such variables 3367 and the backward_sequence will be empty. 3368 """ 3369 3370 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3371 3372 def __init__(self, *args, **kwargs): 3373 raise AttributeError("No constructor defined") 3374 __repr__ = _swig_repr 3375 3376 def Var(self): 3377 return _pywrapcp.SequenceVarElement_Var(self) 3378 3379 def ForwardSequence(self): 3380 return _pywrapcp.SequenceVarElement_ForwardSequence(self) 3381 3382 def BackwardSequence(self): 3383 return _pywrapcp.SequenceVarElement_BackwardSequence(self) 3384 3385 def Unperformed(self): 3386 return _pywrapcp.SequenceVarElement_Unperformed(self) 3387 3388 def SetSequence(self, forward_sequence, backward_sequence, unperformed): 3389 return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed) 3390 3391 def SetForwardSequence(self, forward_sequence): 3392 return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence) 3393 3394 def SetBackwardSequence(self, backward_sequence): 3395 return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence) 3396 3397 def SetUnperformed(self, unperformed): 3398 return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed) 3399 3400 def __eq__(self, element): 3401 return _pywrapcp.SequenceVarElement___eq__(self, element) 3402 3403 def __ne__(self, element): 3404 return _pywrapcp.SequenceVarElement___ne__(self, element) 3405 __swig_destroy__ = _pywrapcp.delete_SequenceVarElement 3406 3407# Register SequenceVarElement in _pywrapcp: 3408_pywrapcp.SequenceVarElement_swigregister(SequenceVarElement) 3409class Assignment(PropagationBaseObject): 3410 r""" 3411 An Assignment is a variable -> domains mapping, used 3412 to report solutions to the user. 3413 """ 3414 3415 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3416 3417 def __init__(self, *args, **kwargs): 3418 raise AttributeError("No constructor defined") 3419 __repr__ = _swig_repr 3420 3421 def Clear(self): 3422 return _pywrapcp.Assignment_Clear(self) 3423 3424 def Empty(self): 3425 return _pywrapcp.Assignment_Empty(self) 3426 3427 def Size(self): 3428 return _pywrapcp.Assignment_Size(self) 3429 3430 def NumIntVars(self): 3431 return _pywrapcp.Assignment_NumIntVars(self) 3432 3433 def NumIntervalVars(self): 3434 return _pywrapcp.Assignment_NumIntervalVars(self) 3435 3436 def NumSequenceVars(self): 3437 return _pywrapcp.Assignment_NumSequenceVars(self) 3438 3439 def Store(self): 3440 return _pywrapcp.Assignment_Store(self) 3441 3442 def Restore(self): 3443 return _pywrapcp.Assignment_Restore(self) 3444 3445 def Load(self, *args): 3446 return _pywrapcp.Assignment_Load(self, *args) 3447 3448 def Save(self, *args): 3449 return _pywrapcp.Assignment_Save(self, *args) 3450 3451 def AddObjective(self, v): 3452 return _pywrapcp.Assignment_AddObjective(self, v) 3453 3454 def Objective(self): 3455 return _pywrapcp.Assignment_Objective(self) 3456 3457 def HasObjective(self): 3458 return _pywrapcp.Assignment_HasObjective(self) 3459 3460 def ObjectiveMin(self): 3461 return _pywrapcp.Assignment_ObjectiveMin(self) 3462 3463 def ObjectiveMax(self): 3464 return _pywrapcp.Assignment_ObjectiveMax(self) 3465 3466 def ObjectiveValue(self): 3467 return _pywrapcp.Assignment_ObjectiveValue(self) 3468 3469 def ObjectiveBound(self): 3470 return _pywrapcp.Assignment_ObjectiveBound(self) 3471 3472 def SetObjectiveMin(self, m): 3473 return _pywrapcp.Assignment_SetObjectiveMin(self, m) 3474 3475 def SetObjectiveMax(self, m): 3476 return _pywrapcp.Assignment_SetObjectiveMax(self, m) 3477 3478 def SetObjectiveValue(self, value): 3479 return _pywrapcp.Assignment_SetObjectiveValue(self, value) 3480 3481 def SetObjectiveRange(self, l, u): 3482 return _pywrapcp.Assignment_SetObjectiveRange(self, l, u) 3483 3484 def Min(self, var): 3485 return _pywrapcp.Assignment_Min(self, var) 3486 3487 def Max(self, var): 3488 return _pywrapcp.Assignment_Max(self, var) 3489 3490 def Value(self, var): 3491 return _pywrapcp.Assignment_Value(self, var) 3492 3493 def Bound(self, var): 3494 return _pywrapcp.Assignment_Bound(self, var) 3495 3496 def SetMin(self, var, m): 3497 return _pywrapcp.Assignment_SetMin(self, var, m) 3498 3499 def SetMax(self, var, m): 3500 return _pywrapcp.Assignment_SetMax(self, var, m) 3501 3502 def SetRange(self, var, l, u): 3503 return _pywrapcp.Assignment_SetRange(self, var, l, u) 3504 3505 def SetValue(self, var, value): 3506 return _pywrapcp.Assignment_SetValue(self, var, value) 3507 3508 def StartMin(self, var): 3509 return _pywrapcp.Assignment_StartMin(self, var) 3510 3511 def StartMax(self, var): 3512 return _pywrapcp.Assignment_StartMax(self, var) 3513 3514 def StartValue(self, var): 3515 return _pywrapcp.Assignment_StartValue(self, var) 3516 3517 def DurationMin(self, var): 3518 return _pywrapcp.Assignment_DurationMin(self, var) 3519 3520 def DurationMax(self, var): 3521 return _pywrapcp.Assignment_DurationMax(self, var) 3522 3523 def DurationValue(self, var): 3524 return _pywrapcp.Assignment_DurationValue(self, var) 3525 3526 def EndMin(self, var): 3527 return _pywrapcp.Assignment_EndMin(self, var) 3528 3529 def EndMax(self, var): 3530 return _pywrapcp.Assignment_EndMax(self, var) 3531 3532 def EndValue(self, var): 3533 return _pywrapcp.Assignment_EndValue(self, var) 3534 3535 def PerformedMin(self, var): 3536 return _pywrapcp.Assignment_PerformedMin(self, var) 3537 3538 def PerformedMax(self, var): 3539 return _pywrapcp.Assignment_PerformedMax(self, var) 3540 3541 def PerformedValue(self, var): 3542 return _pywrapcp.Assignment_PerformedValue(self, var) 3543 3544 def SetStartMin(self, var, m): 3545 return _pywrapcp.Assignment_SetStartMin(self, var, m) 3546 3547 def SetStartMax(self, var, m): 3548 return _pywrapcp.Assignment_SetStartMax(self, var, m) 3549 3550 def SetStartRange(self, var, mi, ma): 3551 return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma) 3552 3553 def SetStartValue(self, var, value): 3554 return _pywrapcp.Assignment_SetStartValue(self, var, value) 3555 3556 def SetDurationMin(self, var, m): 3557 return _pywrapcp.Assignment_SetDurationMin(self, var, m) 3558 3559 def SetDurationMax(self, var, m): 3560 return _pywrapcp.Assignment_SetDurationMax(self, var, m) 3561 3562 def SetDurationRange(self, var, mi, ma): 3563 return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma) 3564 3565 def SetDurationValue(self, var, value): 3566 return _pywrapcp.Assignment_SetDurationValue(self, var, value) 3567 3568 def SetEndMin(self, var, m): 3569 return _pywrapcp.Assignment_SetEndMin(self, var, m) 3570 3571 def SetEndMax(self, var, m): 3572 return _pywrapcp.Assignment_SetEndMax(self, var, m) 3573 3574 def SetEndRange(self, var, mi, ma): 3575 return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma) 3576 3577 def SetEndValue(self, var, value): 3578 return _pywrapcp.Assignment_SetEndValue(self, var, value) 3579 3580 def SetPerformedMin(self, var, m): 3581 return _pywrapcp.Assignment_SetPerformedMin(self, var, m) 3582 3583 def SetPerformedMax(self, var, m): 3584 return _pywrapcp.Assignment_SetPerformedMax(self, var, m) 3585 3586 def SetPerformedRange(self, var, mi, ma): 3587 return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma) 3588 3589 def SetPerformedValue(self, var, value): 3590 return _pywrapcp.Assignment_SetPerformedValue(self, var, value) 3591 3592 def Add(self, *args): 3593 return _pywrapcp.Assignment_Add(self, *args) 3594 3595 def ForwardSequence(self, var): 3596 return _pywrapcp.Assignment_ForwardSequence(self, var) 3597 3598 def BackwardSequence(self, var): 3599 return _pywrapcp.Assignment_BackwardSequence(self, var) 3600 3601 def Unperformed(self, var): 3602 return _pywrapcp.Assignment_Unperformed(self, var) 3603 3604 def SetSequence(self, var, forward_sequence, backward_sequence, unperformed): 3605 return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed) 3606 3607 def SetForwardSequence(self, var, forward_sequence): 3608 return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence) 3609 3610 def SetBackwardSequence(self, var, backward_sequence): 3611 return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence) 3612 3613 def SetUnperformed(self, var, unperformed): 3614 return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed) 3615 3616 def Activate(self, *args): 3617 return _pywrapcp.Assignment_Activate(self, *args) 3618 3619 def Deactivate(self, *args): 3620 return _pywrapcp.Assignment_Deactivate(self, *args) 3621 3622 def Activated(self, *args): 3623 return _pywrapcp.Assignment_Activated(self, *args) 3624 3625 def DebugString(self): 3626 return _pywrapcp.Assignment_DebugString(self) 3627 3628 def IntVarContainer(self): 3629 return _pywrapcp.Assignment_IntVarContainer(self) 3630 3631 def MutableIntVarContainer(self): 3632 return _pywrapcp.Assignment_MutableIntVarContainer(self) 3633 3634 def IntervalVarContainer(self): 3635 return _pywrapcp.Assignment_IntervalVarContainer(self) 3636 3637 def MutableIntervalVarContainer(self): 3638 return _pywrapcp.Assignment_MutableIntervalVarContainer(self) 3639 3640 def SequenceVarContainer(self): 3641 return _pywrapcp.Assignment_SequenceVarContainer(self) 3642 3643 def MutableSequenceVarContainer(self): 3644 return _pywrapcp.Assignment_MutableSequenceVarContainer(self) 3645 3646 def __eq__(self, assignment): 3647 return _pywrapcp.Assignment___eq__(self, assignment) 3648 3649 def __ne__(self, assignment): 3650 return _pywrapcp.Assignment___ne__(self, assignment) 3651 3652# Register Assignment in _pywrapcp: 3653_pywrapcp.Assignment_swigregister(Assignment) 3654 3655def __lshift__(*args): 3656 return _pywrapcp.__lshift__(*args) 3657class Pack(Constraint): 3658 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3659 3660 def __init__(self, *args, **kwargs): 3661 raise AttributeError("No constructor defined") 3662 __repr__ = _swig_repr 3663 3664 def AddWeightedSumLessOrEqualConstantDimension(self, *args): 3665 r""" 3666 *Overload 1:* 3667 Dimensions are additional constraints than can restrict what is 3668 possible with the pack constraint. It can be used to set capacity 3669 limits, to count objects per bin, to compute unassigned 3670 penalties... 3671 This dimension imposes that for all bins b, the weighted sum 3672 (weights[i]) of all objects i assigned to 'b' is less or equal 3673 'bounds[b]'. 3674 3675 | 3676 3677 *Overload 2:* 3678 This dimension imposes that for all bins b, the weighted sum 3679 (weights->Run(i)) of all objects i assigned to 'b' is less or 3680 equal to 'bounds[b]'. Ownership of the callback is transferred to 3681 the pack constraint. 3682 3683 | 3684 3685 *Overload 3:* 3686 This dimension imposes that for all bins b, the weighted sum 3687 (weights->Run(i, b) of all objects i assigned to 'b' is less or 3688 equal to 'bounds[b]'. Ownership of the callback is transferred to 3689 the pack constraint. 3690 """ 3691 return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args) 3692 3693 def AddWeightedSumEqualVarDimension(self, *args): 3694 r""" 3695 *Overload 1:* 3696 This dimension imposes that for all bins b, the weighted sum 3697 (weights[i]) of all objects i assigned to 'b' is equal to loads[b]. 3698 3699 | 3700 3701 *Overload 2:* 3702 This dimension imposes that for all bins b, the weighted sum 3703 (weights->Run(i, b)) of all objects i assigned to 'b' is equal to 3704 loads[b]. 3705 """ 3706 return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args) 3707 3708 def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity): 3709 r""" 3710 This dimension imposes: 3711 forall b in bins, 3712 sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] 3713 where is_assigned(i, b) is true if and only if item i is assigned 3714 to the bin b. 3715 3716 This can be used to model shapes of items by linking variables of 3717 the same item on parallel dimensions with an allowed assignment 3718 constraint. 3719 """ 3720 return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity) 3721 3722 def AddWeightedSumOfAssignedDimension(self, weights, cost_var): 3723 r""" 3724 This dimension enforces that cost_var == sum of weights[i] for 3725 all objects 'i' assigned to a bin. 3726 """ 3727 return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var) 3728 3729 def AddCountUsedBinDimension(self, count_var): 3730 r""" 3731 This dimension links 'count_var' to the actual number of bins used in the 3732 pack. 3733 """ 3734 return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var) 3735 3736 def AddCountAssignedItemsDimension(self, count_var): 3737 r""" 3738 This dimension links 'count_var' to the actual number of items 3739 assigned to a bin in the pack. 3740 """ 3741 return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var) 3742 3743 def Post(self): 3744 return _pywrapcp.Pack_Post(self) 3745 3746 def InitialPropagateWrapper(self): 3747 return _pywrapcp.Pack_InitialPropagateWrapper(self) 3748 3749 def DebugString(self): 3750 return _pywrapcp.Pack_DebugString(self) 3751 3752# Register Pack in _pywrapcp: 3753_pywrapcp.Pack_swigregister(Pack) 3754class DisjunctiveConstraint(Constraint): 3755 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3756 3757 def __init__(self, *args, **kwargs): 3758 raise AttributeError("No constructor defined - class is abstract") 3759 __repr__ = _swig_repr 3760 3761 def SequenceVar(self): 3762 r""" Creates a sequence variable from the constraint.""" 3763 return _pywrapcp.DisjunctiveConstraint_SequenceVar(self) 3764 3765 def SetTransitionTime(self, transition_time): 3766 r""" 3767 Add a transition time between intervals. It forces the distance between 3768 the end of interval a and start of interval b that follows it to be at 3769 least transition_time(a, b). This function must always return 3770 a positive or null value. 3771 """ 3772 return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time) 3773 3774 def TransitionTime(self, before_index, after_index): 3775 return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index) 3776 3777# Register DisjunctiveConstraint in _pywrapcp: 3778_pywrapcp.DisjunctiveConstraint_swigregister(DisjunctiveConstraint) 3779class RevInteger(object): 3780 r""" 3781 This class adds reversibility to a POD type. 3782 It contains the stamp optimization. i.e. the SaveValue call is done 3783 only once per node of the search tree. Please note that actual 3784 stamps always starts at 1, thus an initial value of 0 will always 3785 trigger the first SaveValue. 3786 """ 3787 3788 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3789 __repr__ = _swig_repr 3790 3791 def __init__(self, val): 3792 _pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val)) 3793 3794 def Value(self): 3795 return _pywrapcp.RevInteger_Value(self) 3796 3797 def SetValue(self, s, val): 3798 return _pywrapcp.RevInteger_SetValue(self, s, val) 3799 __swig_destroy__ = _pywrapcp.delete_RevInteger 3800 3801# Register RevInteger in _pywrapcp: 3802_pywrapcp.RevInteger_swigregister(RevInteger) 3803class NumericalRevInteger(RevInteger): 3804 r""" Subclass of Rev<T> which adds numerical operations.""" 3805 3806 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3807 __repr__ = _swig_repr 3808 3809 def __init__(self, val): 3810 _pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val)) 3811 3812 def Add(self, s, to_add): 3813 return _pywrapcp.NumericalRevInteger_Add(self, s, to_add) 3814 3815 def Incr(self, s): 3816 return _pywrapcp.NumericalRevInteger_Incr(self, s) 3817 3818 def Decr(self, s): 3819 return _pywrapcp.NumericalRevInteger_Decr(self, s) 3820 __swig_destroy__ = _pywrapcp.delete_NumericalRevInteger 3821 3822# Register NumericalRevInteger in _pywrapcp: 3823_pywrapcp.NumericalRevInteger_swigregister(NumericalRevInteger) 3824class RevBool(object): 3825 r""" 3826 This class adds reversibility to a POD type. 3827 It contains the stamp optimization. i.e. the SaveValue call is done 3828 only once per node of the search tree. Please note that actual 3829 stamps always starts at 1, thus an initial value of 0 will always 3830 trigger the first SaveValue. 3831 """ 3832 3833 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3834 __repr__ = _swig_repr 3835 3836 def __init__(self, val): 3837 _pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val)) 3838 3839 def Value(self): 3840 return _pywrapcp.RevBool_Value(self) 3841 3842 def SetValue(self, s, val): 3843 return _pywrapcp.RevBool_SetValue(self, s, val) 3844 __swig_destroy__ = _pywrapcp.delete_RevBool 3845 3846# Register RevBool in _pywrapcp: 3847_pywrapcp.RevBool_swigregister(RevBool) 3848class IntVarContainer(object): 3849 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3850 3851 def __init__(self, *args, **kwargs): 3852 raise AttributeError("No constructor defined") 3853 __repr__ = _swig_repr 3854 3855 def Contains(self, var): 3856 return _pywrapcp.IntVarContainer_Contains(self, var) 3857 3858 def Element(self, index): 3859 return _pywrapcp.IntVarContainer_Element(self, index) 3860 3861 def Size(self): 3862 return _pywrapcp.IntVarContainer_Size(self) 3863 3864 def Store(self): 3865 return _pywrapcp.IntVarContainer_Store(self) 3866 3867 def Restore(self): 3868 return _pywrapcp.IntVarContainer_Restore(self) 3869 3870 def __eq__(self, container): 3871 r""" 3872 Returns true if this and 'container' both represent the same V* -> E map. 3873 Runs in linear time; requires that the == operator on the type E is well 3874 defined. 3875 """ 3876 return _pywrapcp.IntVarContainer___eq__(self, container) 3877 3878 def __ne__(self, container): 3879 return _pywrapcp.IntVarContainer___ne__(self, container) 3880 __swig_destroy__ = _pywrapcp.delete_IntVarContainer 3881 3882# Register IntVarContainer in _pywrapcp: 3883_pywrapcp.IntVarContainer_swigregister(IntVarContainer) 3884class IntervalVarContainer(object): 3885 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3886 3887 def __init__(self, *args, **kwargs): 3888 raise AttributeError("No constructor defined") 3889 __repr__ = _swig_repr 3890 3891 def Contains(self, var): 3892 return _pywrapcp.IntervalVarContainer_Contains(self, var) 3893 3894 def Element(self, index): 3895 return _pywrapcp.IntervalVarContainer_Element(self, index) 3896 3897 def Size(self): 3898 return _pywrapcp.IntervalVarContainer_Size(self) 3899 3900 def Store(self): 3901 return _pywrapcp.IntervalVarContainer_Store(self) 3902 3903 def Restore(self): 3904 return _pywrapcp.IntervalVarContainer_Restore(self) 3905 3906 def __eq__(self, container): 3907 r""" 3908 Returns true if this and 'container' both represent the same V* -> E map. 3909 Runs in linear time; requires that the == operator on the type E is well 3910 defined. 3911 """ 3912 return _pywrapcp.IntervalVarContainer___eq__(self, container) 3913 3914 def __ne__(self, container): 3915 return _pywrapcp.IntervalVarContainer___ne__(self, container) 3916 __swig_destroy__ = _pywrapcp.delete_IntervalVarContainer 3917 3918# Register IntervalVarContainer in _pywrapcp: 3919_pywrapcp.IntervalVarContainer_swigregister(IntervalVarContainer) 3920class SequenceVarContainer(object): 3921 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3922 3923 def __init__(self, *args, **kwargs): 3924 raise AttributeError("No constructor defined") 3925 __repr__ = _swig_repr 3926 3927 def Contains(self, var): 3928 return _pywrapcp.SequenceVarContainer_Contains(self, var) 3929 3930 def Element(self, index): 3931 return _pywrapcp.SequenceVarContainer_Element(self, index) 3932 3933 def Size(self): 3934 return _pywrapcp.SequenceVarContainer_Size(self) 3935 3936 def Store(self): 3937 return _pywrapcp.SequenceVarContainer_Store(self) 3938 3939 def Restore(self): 3940 return _pywrapcp.SequenceVarContainer_Restore(self) 3941 3942 def __eq__(self, container): 3943 r""" 3944 Returns true if this and 'container' both represent the same V* -> E map. 3945 Runs in linear time; requires that the == operator on the type E is well 3946 defined. 3947 """ 3948 return _pywrapcp.SequenceVarContainer___eq__(self, container) 3949 3950 def __ne__(self, container): 3951 return _pywrapcp.SequenceVarContainer___ne__(self, container) 3952 __swig_destroy__ = _pywrapcp.delete_SequenceVarContainer 3953 3954# Register SequenceVarContainer in _pywrapcp: 3955_pywrapcp.SequenceVarContainer_swigregister(SequenceVarContainer) 3956class LocalSearchOperator(BaseObject): 3957 r""" 3958 The base class for all local search operators. 3959 3960 A local search operator is an object that defines the neighborhood of a 3961 solution. In other words, a neighborhood is the set of solutions which can 3962 be reached from a given solution using an operator. 3963 3964 The behavior of the LocalSearchOperator class is similar to iterators. 3965 The operator is synchronized with an assignment (gives the 3966 current values of the variables); this is done in the Start() method. 3967 3968 Then one can iterate over the neighbors using the MakeNextNeighbor method. 3969 This method returns an assignment which represents the incremental changes 3970 to the current solution. It also returns a second assignment representing 3971 the changes to the last solution defined by the neighborhood operator; this 3972 assignment is empty if the neighborhood operator cannot track this 3973 information. 3974 """ 3975 3976 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3977 3978 def __init__(self, *args, **kwargs): 3979 raise AttributeError("No constructor defined - class is abstract") 3980 __repr__ = _swig_repr 3981 3982 def NextNeighbor(self, delta, deltadelta): 3983 return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta) 3984 3985 def Start(self, assignment): 3986 return _pywrapcp.LocalSearchOperator_Start(self, assignment) 3987 def __disown__(self): 3988 self.this.disown() 3989 _pywrapcp.disown_LocalSearchOperator(self) 3990 return weakref.proxy(self) 3991 3992# Register LocalSearchOperator in _pywrapcp: 3993_pywrapcp.LocalSearchOperator_swigregister(LocalSearchOperator) 3994class IntVarLocalSearchOperator(LocalSearchOperator): 3995 r""" 3996 Specialization of LocalSearchOperator built from an array of IntVars 3997 which specifies the scope of the operator. 3998 This class also takes care of storing current variable values in Start(), 3999 keeps track of changes done by the operator and builds the delta. 4000 The Deactivate() method can be used to perform Large Neighborhood Search. 4001 """ 4002 4003 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4004 __repr__ = _swig_repr 4005 4006 def __init__(self, vars, keep_inverse_values=False): 4007 if self.__class__ == IntVarLocalSearchOperator: 4008 _self = None 4009 else: 4010 _self = self 4011 _pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, vars, keep_inverse_values)) 4012 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator 4013 4014 def Start(self, assignment): 4015 r""" 4016 This method should not be overridden. Override OnStart() instead which is 4017 called before exiting this method. 4018 """ 4019 return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment) 4020 4021 def IsIncremental(self): 4022 return _pywrapcp.IntVarLocalSearchOperator_IsIncremental(self) 4023 4024 def Size(self): 4025 return _pywrapcp.IntVarLocalSearchOperator_Size(self) 4026 4027 def Value(self, index): 4028 r""" 4029 Returns the value in the current assignment of the variable of given 4030 index. 4031 """ 4032 return _pywrapcp.IntVarLocalSearchOperator_Value(self, index) 4033 4034 def Var(self, index): 4035 r""" Returns the variable of given index.""" 4036 return _pywrapcp.IntVarLocalSearchOperator_Var(self, index) 4037 4038 def OldValue(self, index): 4039 return _pywrapcp.IntVarLocalSearchOperator_OldValue(self, index) 4040 4041 def PrevValue(self, index): 4042 return _pywrapcp.IntVarLocalSearchOperator_PrevValue(self, index) 4043 4044 def SetValue(self, index, value): 4045 return _pywrapcp.IntVarLocalSearchOperator_SetValue(self, index, value) 4046 4047 def Activated(self, index): 4048 return _pywrapcp.IntVarLocalSearchOperator_Activated(self, index) 4049 4050 def Activate(self, index): 4051 return _pywrapcp.IntVarLocalSearchOperator_Activate(self, index) 4052 4053 def Deactivate(self, index): 4054 return _pywrapcp.IntVarLocalSearchOperator_Deactivate(self, index) 4055 4056 def AddVars(self, vars): 4057 return _pywrapcp.IntVarLocalSearchOperator_AddVars(self, vars) 4058 4059 def OnStart(self): 4060 r""" 4061 Called by Start() after synchronizing the operator with the current 4062 assignment. Should be overridden instead of Start() to avoid calling 4063 IntVarLocalSearchOperator::Start explicitly. 4064 """ 4065 return _pywrapcp.IntVarLocalSearchOperator_OnStart(self) 4066 4067 def NextNeighbor(self, delta, deltadelta): 4068 r""" 4069 OnStart() should really be protected, but then SWIG doesn't see it. So we 4070 make it public, but only subclasses should access to it (to override it). 4071 Redefines MakeNextNeighbor to export a simpler interface. The calls to 4072 ApplyChanges() and RevertChanges() are factored in this method, hiding 4073 both delta and deltadelta from subclasses which only need to override 4074 MakeOneNeighbor(). 4075 Therefore this method should not be overridden. Override MakeOneNeighbor() 4076 instead. 4077 """ 4078 return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta) 4079 4080 def OneNeighbor(self): 4081 r""" 4082 Creates a new neighbor. It returns false when the neighborhood is 4083 completely explored. 4084 MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. 4085 """ 4086 return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self) 4087 def __disown__(self): 4088 self.this.disown() 4089 _pywrapcp.disown_IntVarLocalSearchOperator(self) 4090 return weakref.proxy(self) 4091 4092# Register IntVarLocalSearchOperator in _pywrapcp: 4093_pywrapcp.IntVarLocalSearchOperator_swigregister(IntVarLocalSearchOperator) 4094class BaseLns(IntVarLocalSearchOperator): 4095 r""" 4096 This is the base class for building an Lns operator. An Lns fragment is a 4097 collection of variables which will be relaxed. Fragments are built with 4098 NextFragment(), which returns false if there are no more fragments to build. 4099 Optionally one can override InitFragments, which is called from 4100 LocalSearchOperator::Start to initialize fragment data. 4101 4102 Here's a sample relaxing one variable at a time: 4103 4104 class OneVarLns : public BaseLns { 4105 public: 4106 OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {} 4107 virtual ~OneVarLns() {} 4108 virtual void InitFragments() { index_ = 0; } 4109 virtual bool NextFragment() { 4110 const int size = Size(); 4111 if (index_ < size) { 4112 AppendToFragment(index_); 4113 ++index_; 4114 return true; 4115 } else { 4116 return false; 4117 } 4118 } 4119 4120 private: 4121 int index_; 4122 }; 4123 """ 4124 4125 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4126 __repr__ = _swig_repr 4127 4128 def __init__(self, vars): 4129 if self.__class__ == BaseLns: 4130 _self = None 4131 else: 4132 _self = self 4133 _pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars)) 4134 __swig_destroy__ = _pywrapcp.delete_BaseLns 4135 4136 def InitFragments(self): 4137 return _pywrapcp.BaseLns_InitFragments(self) 4138 4139 def NextFragment(self): 4140 return _pywrapcp.BaseLns_NextFragment(self) 4141 4142 def AppendToFragment(self, index): 4143 return _pywrapcp.BaseLns_AppendToFragment(self, index) 4144 4145 def FragmentSize(self): 4146 return _pywrapcp.BaseLns_FragmentSize(self) 4147 4148 def __getitem__(self, index): 4149 return _pywrapcp.BaseLns___getitem__(self, index) 4150 4151 def __len__(self): 4152 return _pywrapcp.BaseLns___len__(self) 4153 def __disown__(self): 4154 self.this.disown() 4155 _pywrapcp.disown_BaseLns(self) 4156 return weakref.proxy(self) 4157 4158# Register BaseLns in _pywrapcp: 4159_pywrapcp.BaseLns_swigregister(BaseLns) 4160class ChangeValue(IntVarLocalSearchOperator): 4161 r""" 4162 Defines operators which change the value of variables; 4163 each neighbor corresponds to *one* modified variable. 4164 Sub-classes have to define ModifyValue which determines what the new 4165 variable value is going to be (given the current value and the variable). 4166 """ 4167 4168 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4169 __repr__ = _swig_repr 4170 4171 def __init__(self, vars): 4172 if self.__class__ == ChangeValue: 4173 _self = None 4174 else: 4175 _self = self 4176 _pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars)) 4177 __swig_destroy__ = _pywrapcp.delete_ChangeValue 4178 4179 def ModifyValue(self, index, value): 4180 return _pywrapcp.ChangeValue_ModifyValue(self, index, value) 4181 4182 def OneNeighbor(self): 4183 r""" This method should not be overridden. Override ModifyValue() instead.""" 4184 return _pywrapcp.ChangeValue_OneNeighbor(self) 4185 def __disown__(self): 4186 self.this.disown() 4187 _pywrapcp.disown_ChangeValue(self) 4188 return weakref.proxy(self) 4189 4190# Register ChangeValue in _pywrapcp: 4191_pywrapcp.ChangeValue_swigregister(ChangeValue) 4192class PathOperator(IntVarLocalSearchOperator): 4193 r""" 4194 Base class of the local search operators dedicated to path modifications 4195 (a path is a set of nodes linked together by arcs). 4196 This family of neighborhoods supposes they are handling next variables 4197 representing the arcs (var[i] represents the node immediately after i on 4198 a path). 4199 Several services are provided: 4200 - arc manipulators (SetNext(), ReverseChain(), MoveChain()) 4201 - path inspectors (Next(), Prev(), IsPathEnd()) 4202 - path iterators: operators need a given number of nodes to define a 4203 neighbor; this class provides the iteration on a given number of (base) 4204 nodes which can be used to define a neighbor (through the BaseNode method) 4205 Subclasses only need to override MakeNeighbor to create neighbors using 4206 the services above (no direct manipulation of assignments). 4207 """ 4208 4209 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4210 4211 def __init__(self, *args, **kwargs): 4212 raise AttributeError("No constructor defined - class is abstract") 4213 __repr__ = _swig_repr 4214 4215 def Neighbor(self): 4216 return _pywrapcp.PathOperator_Neighbor(self) 4217 4218# Register PathOperator in _pywrapcp: 4219_pywrapcp.PathOperator_swigregister(PathOperator) 4220class LocalSearchFilter(BaseObject): 4221 r""" 4222 Classes to which this template function can be applied to as of 04/2014. 4223 Usage: LocalSearchOperator* op = MakeLocalSearchOperator<Relocate>(...); 4224 class TwoOpt; 4225 class Relocate; 4226 class Exchange; 4227 class Cross; 4228 class MakeActiveOperator; 4229 class MakeInactiveOperator; 4230 class MakeChainInactiveOperator; 4231 class SwapActiveOperator; 4232 class ExtendedSwapActiveOperator; 4233 class MakeActiveAndRelocate; 4234 class RelocateAndMakeActiveOperator; 4235 class RelocateAndMakeInactiveOperator; 4236 Local Search Filters are used for fast neighbor pruning. 4237 Filtering a move is done in several phases: 4238 - in the Relax phase, filters determine which parts of their internals 4239 will be changed by the candidate, and modify intermediary State 4240 - in the Accept phase, filters check that the candidate is feasible, 4241 - if the Accept phase succeeds, the solver may decide to trigger a 4242 Synchronize phase that makes filters change their internal representation 4243 to the last candidate, 4244 - otherwise (Accept fails or the solver does not want to synchronize), 4245 a Revert phase makes filters erase any intermediary State generated by the 4246 Relax and Accept phases. 4247 A given filter has phases called with the following pattern: 4248 (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. 4249 Filters's Revert() is always called in the reverse order their Accept() was 4250 called, to allow late filters to use state done/undone by early filters' 4251 Accept()/Revert(). 4252 """ 4253 4254 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4255 4256 def __init__(self, *args, **kwargs): 4257 raise AttributeError("No constructor defined - class is abstract") 4258 __repr__ = _swig_repr 4259 4260 def Accept(self, delta, deltadelta, objective_min, objective_max): 4261 r""" 4262 Accepts a "delta" given the assignment with which the filter has been 4263 synchronized; the delta holds the variables which have been modified and 4264 their new value. 4265 If the filter represents a part of the global objective, its contribution 4266 must be between objective_min and objective_max. 4267 Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, 4268 for the assignment (a,1), (b,0), the delta (b,1) will be rejected 4269 but the delta (a,0) will be accepted. 4270 TODO(user): Remove arguments when there are no more need for those. 4271 """ 4272 return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max) 4273 4274 def IsIncremental(self): 4275 return _pywrapcp.LocalSearchFilter_IsIncremental(self) 4276 4277 def Synchronize(self, assignment, delta): 4278 r""" 4279 Synchronizes the filter with the current solution, delta being the 4280 difference with the solution passed to the previous call to Synchronize() 4281 or IncrementalSynchronize(). 'delta' can be used to incrementally 4282 synchronizing the filter with the new solution by only considering the 4283 changes in delta. 4284 """ 4285 return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta) 4286 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilter 4287 4288# Register LocalSearchFilter in _pywrapcp: 4289_pywrapcp.LocalSearchFilter_swigregister(LocalSearchFilter) 4290class LocalSearchFilterManager(BaseObject): 4291 r""" 4292 Filter manager: when a move is made, filters are executed to decide whether 4293 the solution is feasible and compute parts of the new cost. This class 4294 schedules filter execution and composes costs as a sum. 4295 """ 4296 4297 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4298 __repr__ = _swig_repr 4299 4300 def DebugString(self): 4301 return _pywrapcp.LocalSearchFilterManager_DebugString(self) 4302 4303 def __init__(self, *args): 4304 _pywrapcp.LocalSearchFilterManager_swiginit(self, _pywrapcp.new_LocalSearchFilterManager(*args)) 4305 4306 def Accept(self, monitor, delta, deltadelta, objective_min, objective_max): 4307 r""" 4308 Returns true iff all filters return true, and the sum of their accepted 4309 objectives is between objective_min and objective_max. 4310 The monitor has its Begin/EndFiltering events triggered. 4311 """ 4312 return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max) 4313 4314 def Synchronize(self, assignment, delta): 4315 r""" Synchronizes all filters to assignment.""" 4316 return _pywrapcp.LocalSearchFilterManager_Synchronize(self, assignment, delta) 4317 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilterManager 4318 4319# Register LocalSearchFilterManager in _pywrapcp: 4320_pywrapcp.LocalSearchFilterManager_swigregister(LocalSearchFilterManager) 4321class IntVarLocalSearchFilter(LocalSearchFilter): 4322 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4323 __repr__ = _swig_repr 4324 4325 def __init__(self, vars): 4326 if self.__class__ == IntVarLocalSearchFilter: 4327 _self = None 4328 else: 4329 _self = self 4330 _pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, vars)) 4331 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter 4332 4333 def Synchronize(self, assignment, delta): 4334 r""" 4335 This method should not be overridden. Override OnSynchronize() instead 4336 which is called before exiting this method. 4337 """ 4338 return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta) 4339 4340 def Size(self): 4341 return _pywrapcp.IntVarLocalSearchFilter_Size(self) 4342 4343 def Value(self, index): 4344 return _pywrapcp.IntVarLocalSearchFilter_Value(self, index) 4345 4346 def IndexFromVar(self, var): 4347 return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var) 4348 def __disown__(self): 4349 self.this.disown() 4350 _pywrapcp.disown_IntVarLocalSearchFilter(self) 4351 return weakref.proxy(self) 4352 4353# Register IntVarLocalSearchFilter in _pywrapcp: 4354_pywrapcp.IntVarLocalSearchFilter_swigregister(IntVarLocalSearchFilter) 4355class BooleanVar(IntVar): 4356 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4357 4358 def __init__(self, *args, **kwargs): 4359 raise AttributeError("No constructor defined - class is abstract") 4360 __repr__ = _swig_repr 4361 4362 def Min(self): 4363 return _pywrapcp.BooleanVar_Min(self) 4364 4365 def SetMin(self, m): 4366 return _pywrapcp.BooleanVar_SetMin(self, m) 4367 4368 def Max(self): 4369 return _pywrapcp.BooleanVar_Max(self) 4370 4371 def SetMax(self, m): 4372 return _pywrapcp.BooleanVar_SetMax(self, m) 4373 4374 def SetRange(self, mi, ma): 4375 return _pywrapcp.BooleanVar_SetRange(self, mi, ma) 4376 4377 def Bound(self): 4378 return _pywrapcp.BooleanVar_Bound(self) 4379 4380 def Value(self): 4381 return _pywrapcp.BooleanVar_Value(self) 4382 4383 def RemoveValue(self, v): 4384 return _pywrapcp.BooleanVar_RemoveValue(self, v) 4385 4386 def RemoveInterval(self, l, u): 4387 return _pywrapcp.BooleanVar_RemoveInterval(self, l, u) 4388 4389 def WhenBound(self, d): 4390 return _pywrapcp.BooleanVar_WhenBound(self, d) 4391 4392 def WhenRange(self, d): 4393 return _pywrapcp.BooleanVar_WhenRange(self, d) 4394 4395 def WhenDomain(self, d): 4396 return _pywrapcp.BooleanVar_WhenDomain(self, d) 4397 4398 def Size(self): 4399 return _pywrapcp.BooleanVar_Size(self) 4400 4401 def Contains(self, v): 4402 return _pywrapcp.BooleanVar_Contains(self, v) 4403 4404 def HoleIteratorAux(self, reversible): 4405 return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible) 4406 4407 def DomainIteratorAux(self, reversible): 4408 return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible) 4409 4410 def DebugString(self): 4411 return _pywrapcp.BooleanVar_DebugString(self) 4412 4413# Register BooleanVar in _pywrapcp: 4414_pywrapcp.BooleanVar_swigregister(BooleanVar) 4415 4416class PyDecision(Decision): 4417 4418 def __init__(self): 4419 Decision.__init__(self) 4420 4421 def ApplyWrapper(self, solver): 4422 try: 4423 self.Apply(solver) 4424 except Exception as e: 4425 if 'CP Solver fail' in str(e): 4426 solver.ShouldFail() 4427 else: 4428 raise 4429 4430 def RefuteWrapper(self, solver): 4431 try: 4432 self.Refute(solver) 4433 except Exception as e: 4434 if 'CP Solver fail' in str(e): 4435 solver.ShouldFail() 4436 else: 4437 raise 4438 4439 def DebugString(self): 4440 return "PyDecision" 4441 4442 4443class PyDecisionBuilder(DecisionBuilder): 4444 4445 def __init__(self): 4446 DecisionBuilder.__init__(self) 4447 4448 def NextWrapper(self, solver): 4449 try: 4450 return self.Next(solver) 4451 except Exception as e: 4452 if 'CP Solver fail' in str(e): 4453 return solver.FailDecision() 4454 else: 4455 raise 4456 4457 def DebugString(self): 4458 return "PyDecisionBuilder" 4459 4460 4461class PyDemon(Demon): 4462 4463 def RunWrapper(self, solver): 4464 try: 4465 self.Run(solver) 4466 except Exception as e: 4467 if 'CP Solver fail' in str(e): 4468 solver.ShouldFail() 4469 else: 4470 raise 4471 4472 def DebugString(self): 4473 return "PyDemon" 4474 4475 4476class PyConstraintDemon(PyDemon): 4477 4478 def __init__(self, ct, method, delayed, *args): 4479 PyDemon.__init__(self) 4480 self.__constraint = ct 4481 self.__method = method 4482 self.__delayed = delayed 4483 self.__args = args 4484 4485 def Run(self, solver): 4486 self.__method(self.__constraint, *self.__args) 4487 4488 def Priority(self): 4489 return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY 4490 4491 def DebugString(self): 4492 return 'PyConstraintDemon' 4493 4494 4495class PyConstraint(Constraint): 4496 4497 def __init__(self, solver): 4498 Constraint.__init__(self, solver) 4499 self.__demons = [] 4500 4501 def Demon(self, method, *args): 4502 demon = PyConstraintDemon(self, method, False, *args) 4503 self.__demons.append(demon) 4504 return demon 4505 4506 def DelayedDemon(self, method, *args): 4507 demon = PyConstraintDemon(self, method, True, *args) 4508 self.__demons.append(demon) 4509 return demon 4510 4511 def InitialPropagateDemon(self): 4512 return self.solver().ConstraintInitialPropagateCallback(self) 4513 4514 def DelayedInitialPropagateDemon(self): 4515 return self.solver().DelayedConstraintInitialPropagateCallback(self) 4516 4517 def InitialPropagateWrapper(self): 4518 try: 4519 self.InitialPropagate() 4520 except Exception as e: 4521 if 'CP Solver fail' in str(e): 4522 self.solver().ShouldFail() 4523 else: 4524 raise 4525 4526 def DebugString(self): 4527 return "PyConstraint" 4528 4529 4530 4531class RoutingIndexManager(object): 4532 r""" 4533 Manager for any NodeIndex <-> variable index conversion. The routing solver 4534 uses variable indices internally and through its API. These variable indices 4535 are tricky to manage directly because one Node can correspond to a multitude 4536 of variables, depending on the number of times they appear in the model, and 4537 if they're used as start and/or end points. This class aims to simplify 4538 variable index usage, allowing users to use NodeIndex instead. 4539 4540 Usage: 4541 4542 .. code-block:: c++ 4543 4544 auto starts_ends = ...; /// These are NodeIndex. 4545 RoutingIndexManager manager(10, 4, starts_ends); // 10 nodes, 4 vehicles. 4546 RoutingModel model(manager); 4547 4548 Then, use 'manager.NodeToIndex(node)' whenever model requires a variable 4549 index. 4550 4551 Note: the mapping between node indices and variables indices is subject to 4552 change so no assumption should be made on it. The only guarantee is that 4553 indices range between 0 and n-1, where n = number of vehicles * 2 (for start 4554 and end nodes) + number of non-start or end nodes. 4555 """ 4556 4557 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4558 __repr__ = _swig_repr 4559 4560 def __init__(self, *args): 4561 _pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args)) 4562 4563 def GetNumberOfNodes(self): 4564 return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self) 4565 4566 def GetNumberOfVehicles(self): 4567 return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self) 4568 4569 def GetNumberOfIndices(self): 4570 return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self) 4571 4572 def GetStartIndex(self, vehicle): 4573 return _pywrapcp.RoutingIndexManager_GetStartIndex(self, vehicle) 4574 4575 def GetEndIndex(self, vehicle): 4576 return _pywrapcp.RoutingIndexManager_GetEndIndex(self, vehicle) 4577 4578 def NodeToIndex(self, node): 4579 return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node) 4580 4581 def IndexToNode(self, index): 4582 return _pywrapcp.RoutingIndexManager_IndexToNode(self, index) 4583 __swig_destroy__ = _pywrapcp.delete_RoutingIndexManager 4584 4585# Register RoutingIndexManager in _pywrapcp: 4586_pywrapcp.RoutingIndexManager_swigregister(RoutingIndexManager) 4587 4588def DefaultRoutingModelParameters(): 4589 return _pywrapcp.DefaultRoutingModelParameters() 4590 4591def DefaultRoutingSearchParameters(): 4592 return _pywrapcp.DefaultRoutingSearchParameters() 4593 4594def FindErrorInRoutingSearchParameters(search_parameters): 4595 r""" 4596 Returns an empty std::string if the routing search parameters are valid, and 4597 a non-empty, human readable error description if they're not. 4598 """ 4599 return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters) 4600BOOL_UNSPECIFIED = _pywrapcp.BOOL_UNSPECIFIED 4601BOOL_FALSE = _pywrapcp.BOOL_FALSE 4602BOOL_TRUE = _pywrapcp.BOOL_TRUE 4603class FirstSolutionStrategy(object): 4604 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4605 __repr__ = _swig_repr 4606 4607 def __init__(self): 4608 _pywrapcp.FirstSolutionStrategy_swiginit(self, _pywrapcp.new_FirstSolutionStrategy()) 4609 __swig_destroy__ = _pywrapcp.delete_FirstSolutionStrategy 4610 4611# Register FirstSolutionStrategy in _pywrapcp: 4612_pywrapcp.FirstSolutionStrategy_swigregister(FirstSolutionStrategy) 4613class LocalSearchMetaheuristic(object): 4614 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4615 __repr__ = _swig_repr 4616 4617 def __init__(self): 4618 _pywrapcp.LocalSearchMetaheuristic_swiginit(self, _pywrapcp.new_LocalSearchMetaheuristic()) 4619 __swig_destroy__ = _pywrapcp.delete_LocalSearchMetaheuristic 4620 4621# Register LocalSearchMetaheuristic in _pywrapcp: 4622_pywrapcp.LocalSearchMetaheuristic_swigregister(LocalSearchMetaheuristic) 4623class PathsMetadata(object): 4624 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4625 __repr__ = _swig_repr 4626 4627 def __init__(self, manager): 4628 _pywrapcp.PathsMetadata_swiginit(self, _pywrapcp.new_PathsMetadata(manager)) 4629 4630 def IsStart(self, node): 4631 return _pywrapcp.PathsMetadata_IsStart(self, node) 4632 4633 def IsEnd(self, node): 4634 return _pywrapcp.PathsMetadata_IsEnd(self, node) 4635 4636 def GetPath(self, start_or_end_node): 4637 return _pywrapcp.PathsMetadata_GetPath(self, start_or_end_node) 4638 4639 def NumPaths(self): 4640 return _pywrapcp.PathsMetadata_NumPaths(self) 4641 4642 def Paths(self): 4643 return _pywrapcp.PathsMetadata_Paths(self) 4644 4645 def Starts(self): 4646 return _pywrapcp.PathsMetadata_Starts(self) 4647 4648 def Ends(self): 4649 return _pywrapcp.PathsMetadata_Ends(self) 4650 __swig_destroy__ = _pywrapcp.delete_PathsMetadata 4651 4652# Register PathsMetadata in _pywrapcp: 4653_pywrapcp.PathsMetadata_swigregister(PathsMetadata) 4654class RoutingModel(object): 4655 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4656 __repr__ = _swig_repr 4657 ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED 4658 r""" Problem not solved yet (before calling RoutingModel::Solve()).""" 4659 ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS 4660 r""" Problem solved successfully after calling RoutingModel::Solve().""" 4661 ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED = _pywrapcp.RoutingModel_ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED 4662 r""" 4663 Problem solved successfully after calling RoutingModel::Solve(), except 4664 that a local optimum has not been reached. Leaving more time would allow 4665 improving the solution. 4666 """ 4667 ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL 4668 r""" No solution found to the problem after calling RoutingModel::Solve().""" 4669 ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT 4670 r""" Time limit reached before finding a solution with RoutingModel::Solve().""" 4671 ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID 4672 r""" Model, model parameters or flags are not valid.""" 4673 ROUTING_INFEASIBLE = _pywrapcp.RoutingModel_ROUTING_INFEASIBLE 4674 r""" Problem proven to be infeasible.""" 4675 PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER 4676 r""" Any precedence is accepted.""" 4677 PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO 4678 r""" Deliveries must be performed in reverse order of pickups.""" 4679 PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO 4680 r""" Deliveries must be performed in the same order as pickups.""" 4681 4682 def __init__(self, *args): 4683 _pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args)) 4684 __swig_destroy__ = _pywrapcp.delete_RoutingModel 4685 kTransitEvaluatorSignUnknown = _pywrapcp.RoutingModel_kTransitEvaluatorSignUnknown 4686 kTransitEvaluatorSignPositiveOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignPositiveOrZero 4687 kTransitEvaluatorSignNegativeOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignNegativeOrZero 4688 4689 def RegisterUnaryTransitVector(self, values): 4690 r""" 4691 Registers 'callback' and returns its index. 4692 The sign parameter allows to notify the solver that the callback only 4693 return values of the given sign. This can help the solver, but passing 4694 an incorrect sign may crash in non-opt compilation mode, and yield 4695 incorrect results in opt. 4696 """ 4697 return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values) 4698 4699 def RegisterUnaryTransitCallback(self, *args): 4700 return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, *args) 4701 4702 def RegisterTransitMatrix(self, values): 4703 return _pywrapcp.RoutingModel_RegisterTransitMatrix(self, values) 4704 4705 def RegisterTransitCallback(self, *args): 4706 return _pywrapcp.RoutingModel_RegisterTransitCallback(self, *args) 4707 4708 def TransitCallback(self, callback_index): 4709 return _pywrapcp.RoutingModel_TransitCallback(self, callback_index) 4710 4711 def UnaryTransitCallbackOrNull(self, callback_index): 4712 return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index) 4713 4714 def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name): 4715 r""" 4716 Model creation 4717 Methods to add dimensions to routes; dimensions represent quantities 4718 accumulated at nodes along the routes. They represent quantities such as 4719 weights or volumes carried along the route, or distance or times. 4720 Quantities at a node are represented by "cumul" variables and the increase 4721 or decrease of quantities between nodes are represented by "transit" 4722 variables. These variables are linked as follows: 4723 if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) 4724 where slack is a positive slack variable (can represent waiting times for 4725 a time dimension). 4726 Setting the value of fix_start_cumul_to_zero to true will force the 4727 "cumul" variable of the start node of all vehicles to be equal to 0. 4728 Creates a dimension where the transit variable is constrained to be 4729 equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the 4730 slack variable and 'capacity' is the upper bound of the cumul variables. 4731 'name' is the name used to reference the dimension; this name is used to 4732 get cumul and transit variables from the routing model. 4733 Returns false if a dimension with the same name has already been created 4734 (and doesn't create the new dimension). 4735 Takes ownership of the callback 'evaluator'. 4736 """ 4737 return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name) 4738 4739 def AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name): 4740 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name) 4741 4742 def AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4743 return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4744 4745 def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4746 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4747 4748 def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name): 4749 r""" 4750 Creates a dimension where the transit variable is constrained to be 4751 equal to 'value'; 'capacity' is the upper bound of the cumul variables. 4752 'name' is the name used to reference the dimension; this name is used to 4753 get cumul and transit variables from the routing model. 4754 Returns a pair consisting of an index to the registered unary transit 4755 callback and a bool denoting whether the dimension has been created. 4756 It is false if a dimension with the same name has already been created 4757 (and doesn't create the new dimension but still register a new callback). 4758 """ 4759 return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name) 4760 4761 def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name): 4762 return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name) 4763 4764 def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4765 r""" 4766 Creates a dimension where the transit variable is constrained to be 4767 equal to 'values[i]' for node i; 'capacity' is the upper bound of 4768 the cumul variables. 'name' is the name used to reference the dimension; 4769 this name is used to get cumul and transit variables from the routing 4770 model. 4771 Returns a pair consisting of an index to the registered unary transit 4772 callback and a bool denoting whether the dimension has been created. 4773 It is false if a dimension with the same name has already been created 4774 (and doesn't create the new dimension but still register a new callback). 4775 """ 4776 return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4777 4778 def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4779 r""" 4780 Creates a dimension where the transit variable is constrained to be 4781 equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of 4782 the cumul variables. 'name' is the name used to reference the dimension; 4783 this name is used to get cumul and transit variables from the routing 4784 model. 4785 Returns a pair consisting of an index to the registered transit callback 4786 and a bool denoting whether the dimension has been created. 4787 It is false if a dimension with the same name has already been created 4788 (and doesn't create the new dimension but still register a new callback). 4789 """ 4790 return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4791 4792 def GetAllDimensionNames(self): 4793 r""" Outputs the names of all dimensions added to the routing engine.""" 4794 return _pywrapcp.RoutingModel_GetAllDimensionNames(self) 4795 4796 def GetDimensions(self): 4797 r""" Returns all dimensions of the model.""" 4798 return _pywrapcp.RoutingModel_GetDimensions(self) 4799 4800 def GetDimensionsWithSoftOrSpanCosts(self): 4801 r""" Returns dimensions with soft or vehicle span costs.""" 4802 return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self) 4803 4804 def GetDimensionsWithGlobalCumulOptimizers(self): 4805 r""" Returns the dimensions which have [global|local]_dimension_optimizers_.""" 4806 return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self) 4807 4808 def GetDimensionsWithLocalCumulOptimizers(self): 4809 return _pywrapcp.RoutingModel_GetDimensionsWithLocalCumulOptimizers(self) 4810 4811 def HasGlobalCumulOptimizer(self, dimension): 4812 r""" Returns whether the given dimension has global/local cumul optimizers.""" 4813 return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension) 4814 4815 def HasLocalCumulOptimizer(self, dimension): 4816 return _pywrapcp.RoutingModel_HasLocalCumulOptimizer(self, dimension) 4817 4818 def GetMutableGlobalCumulLPOptimizer(self, dimension): 4819 r""" 4820 Returns the global/local dimension cumul optimizer for a given dimension, 4821 or nullptr if there is none. 4822 """ 4823 return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension) 4824 4825 def GetMutableGlobalCumulMPOptimizer(self, dimension): 4826 return _pywrapcp.RoutingModel_GetMutableGlobalCumulMPOptimizer(self, dimension) 4827 4828 def GetMutableLocalCumulLPOptimizer(self, dimension): 4829 return _pywrapcp.RoutingModel_GetMutableLocalCumulLPOptimizer(self, dimension) 4830 4831 def GetMutableLocalCumulMPOptimizer(self, dimension): 4832 return _pywrapcp.RoutingModel_GetMutableLocalCumulMPOptimizer(self, dimension) 4833 4834 def HasDimension(self, dimension_name): 4835 r""" Returns true if a dimension exists for a given dimension name.""" 4836 return _pywrapcp.RoutingModel_HasDimension(self, dimension_name) 4837 4838 def GetDimensionOrDie(self, dimension_name): 4839 r""" Returns a dimension from its name. Dies if the dimension does not exist.""" 4840 return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name) 4841 4842 def GetMutableDimension(self, dimension_name): 4843 r""" 4844 Returns a dimension from its name. Returns nullptr if the dimension does 4845 not exist. 4846 """ 4847 return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name) 4848 4849 def SetPrimaryConstrainedDimension(self, dimension_name): 4850 r""" 4851 Set the given dimension as "primary constrained". As of August 2013, this 4852 is only used by ArcIsMoreConstrainedThanArc(). 4853 "dimension" must be the name of an existing dimension, or be empty, in 4854 which case there will not be a primary dimension after this call. 4855 """ 4856 return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name) 4857 4858 def GetPrimaryConstrainedDimension(self): 4859 r""" Get the primary constrained dimension, or an empty string if it is unset.""" 4860 return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self) 4861 4862 def AddResourceGroup(self): 4863 r""" 4864 Adds a resource group to the routing model. Returns its index in 4865 resource_groups_. 4866 """ 4867 return _pywrapcp.RoutingModel_AddResourceGroup(self) 4868 4869 def GetResourceGroups(self): 4870 return _pywrapcp.RoutingModel_GetResourceGroups(self) 4871 4872 def GetResourceGroup(self, rg_index): 4873 return _pywrapcp.RoutingModel_GetResourceGroup(self, rg_index) 4874 4875 def GetDimensionResourceGroupIndices(self, dimension): 4876 r""" 4877 Returns the indices of resource groups for this dimension. This method can 4878 only be called after the model has been closed. 4879 """ 4880 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension) 4881 4882 def GetDimensionResourceGroupIndex(self, dimension): 4883 r""" 4884 Returns the index of the resource group attached to the dimension. 4885 DCHECKS that there's exactly one resource group for this dimension. 4886 """ 4887 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension) 4888 4889 def AddDisjunction(self, *args): 4890 r""" 4891 Adds a disjunction constraint on the indices: exactly 'max_cardinality' of 4892 the indices are active. Start and end indices of any vehicle cannot be 4893 part of a disjunction. 4894 4895 If a penalty is given, at most 'max_cardinality' of the indices can be 4896 active, and if less are active, 'penalty' is payed per inactive index. 4897 This is equivalent to adding the constraint: 4898 p + Sum(i)active[i] == max_cardinality 4899 where p is an integer variable, and the following cost to the cost 4900 function: 4901 p * penalty. 4902 'penalty' must be positive to make the disjunction optional; a negative 4903 penalty will force 'max_cardinality' indices of the disjunction to be 4904 performed, and therefore p == 0. 4905 Note: passing a vector with a single index will model an optional index 4906 with a penalty cost if it is not visited. 4907 """ 4908 return _pywrapcp.RoutingModel_AddDisjunction(self, *args) 4909 4910 def GetDisjunctionIndices(self, index): 4911 r""" Returns the indices of the disjunctions to which an index belongs.""" 4912 return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index) 4913 4914 def GetDisjunctionPenalty(self, index): 4915 r""" Returns the penalty of the node disjunction of index 'index'.""" 4916 return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index) 4917 4918 def GetDisjunctionMaxCardinality(self, index): 4919 r""" 4920 Returns the maximum number of possible active nodes of the node 4921 disjunction of index 'index'. 4922 """ 4923 return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index) 4924 4925 def GetNumberOfDisjunctions(self): 4926 r""" Returns the number of node disjunctions in the model.""" 4927 return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self) 4928 4929 def HasMandatoryDisjunctions(self): 4930 r""" 4931 Returns true if the model contains mandatory disjunctions (ones with 4932 kNoPenalty as penalty). 4933 """ 4934 return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self) 4935 4936 def HasMaxCardinalityConstrainedDisjunctions(self): 4937 r""" 4938 Returns true if the model contains at least one disjunction which is 4939 constrained by its max_cardinality. 4940 """ 4941 return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self) 4942 4943 def GetPerfectBinaryDisjunctions(self): 4944 r""" 4945 Returns the list of all perfect binary disjunctions, as pairs of variable 4946 indices: a disjunction is "perfect" when its variables do not appear in 4947 any other disjunction. Each pair is sorted (lowest variable index first), 4948 and the output vector is also sorted (lowest pairs first). 4949 """ 4950 return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self) 4951 4952 def IgnoreDisjunctionsAlreadyForcedToZero(self): 4953 r""" 4954 SPECIAL: Makes the solver ignore all the disjunctions whose active 4955 variables are all trivially zero (i.e. Max() == 0), by setting their 4956 max_cardinality to 0. 4957 This can be useful when using the BaseBinaryDisjunctionNeighborhood 4958 operators, in the context of arc-based routing. 4959 """ 4960 return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self) 4961 4962 def AddSoftSameVehicleConstraint(self, indices, cost): 4963 r""" 4964 Adds a soft constraint to force a set of variable indices to be on the 4965 same vehicle. If all nodes are not on the same vehicle, each extra vehicle 4966 used adds 'cost' to the cost function. 4967 """ 4968 return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost) 4969 4970 def SetAllowedVehiclesForIndex(self, vehicles, index): 4971 r""" 4972 Sets the vehicles which can visit a given node. If the node is in a 4973 disjunction, this will not prevent it from being unperformed. 4974 Specifying an empty vector of vehicles has no effect (all vehicles 4975 will be allowed to visit the node). 4976 """ 4977 return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index) 4978 4979 def IsVehicleAllowedForIndex(self, vehicle, index): 4980 r""" Returns true if a vehicle is allowed to visit a given node.""" 4981 return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index) 4982 4983 def AddPickupAndDelivery(self, pickup, delivery): 4984 r""" 4985 Notifies that index1 and index2 form a pair of nodes which should belong 4986 to the same route. This methods helps the search find better solutions, 4987 especially in the local search phase. 4988 It should be called each time you have an equality constraint linking 4989 the vehicle variables of two node (including for instance pickup and 4990 delivery problems): 4991 Solver* const solver = routing.solver(); 4992 int64_t index1 = manager.NodeToIndex(node1); 4993 int64_t index2 = manager.NodeToIndex(node2); 4994 solver->AddConstraint(solver->MakeEquality( 4995 routing.VehicleVar(index1), 4996 routing.VehicleVar(index2))); 4997 routing.AddPickupAndDelivery(index1, index2); 4998 """ 4999 return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery) 5000 5001 def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction): 5002 r""" 5003 Same as AddPickupAndDelivery but notifying that the performed node from 5004 the disjunction of index 'pickup_disjunction' is on the same route as the 5005 performed node from the disjunction of index 'delivery_disjunction'. 5006 """ 5007 return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction) 5008 5009 def GetPickupIndexPairs(self, node_index): 5010 r""" 5011 Returns pairs for which the node is a pickup; the first element of each 5012 pair is the index in the pickup and delivery pairs list in which the 5013 pickup appears, the second element is its index in the pickups list. 5014 """ 5015 return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index) 5016 5017 def GetDeliveryIndexPairs(self, node_index): 5018 r""" Same as above for deliveries.""" 5019 return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index) 5020 5021 def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy): 5022 r""" 5023 Sets the Pickup and delivery policy of all vehicles. It is equivalent to 5024 calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles. 5025 """ 5026 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy) 5027 5028 def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle): 5029 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle) 5030 5031 def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle): 5032 return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle) 5033 5034 def GetNumOfSingletonNodes(self): 5035 r""" 5036 Returns the number of non-start/end nodes which do not appear in a 5037 pickup/delivery pair. 5038 """ 5039 return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self) 5040 TYPE_ADDED_TO_VEHICLE = _pywrapcp.RoutingModel_TYPE_ADDED_TO_VEHICLE 5041 r""" When visited, the number of types 'T' on the vehicle increases by one.""" 5042 ADDED_TYPE_REMOVED_FROM_VEHICLE = _pywrapcp.RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE 5043 r""" 5044 When visited, one instance of type 'T' previously added to the route 5045 (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle. 5046 If the type was not previously added to the route or all added instances 5047 have already been removed, this visit has no effect on the types. 5048 """ 5049 TYPE_ON_VEHICLE_UP_TO_VISIT = _pywrapcp.RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT 5050 r""" 5051 With the following policy, the visit enforces that type 'T' is 5052 considered on the route from its start until this node is visited. 5053 """ 5054 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = _pywrapcp.RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 5055 r""" 5056 The visit doesn't have an impact on the number of types 'T' on the 5057 route, as it's (virtually) added and removed directly. 5058 This policy can be used for visits which are part of an incompatibility 5059 or requirement set without affecting the type count on the route. 5060 """ 5061 5062 def SetVisitType(self, index, type, type_policy): 5063 return _pywrapcp.RoutingModel_SetVisitType(self, index, type, type_policy) 5064 5065 def GetVisitType(self, index): 5066 return _pywrapcp.RoutingModel_GetVisitType(self, index) 5067 5068 def GetSingleNodesOfType(self, type): 5069 return _pywrapcp.RoutingModel_GetSingleNodesOfType(self, type) 5070 5071 def GetPairIndicesOfType(self, type): 5072 return _pywrapcp.RoutingModel_GetPairIndicesOfType(self, type) 5073 5074 def GetVisitTypePolicy(self, index): 5075 return _pywrapcp.RoutingModel_GetVisitTypePolicy(self, index) 5076 5077 def CloseVisitTypes(self): 5078 r""" 5079 This function should be called once all node visit types have been set and 5080 prior to adding any incompatibilities/requirements. 5081 "close" types. 5082 """ 5083 return _pywrapcp.RoutingModel_CloseVisitTypes(self) 5084 5085 def GetNumberOfVisitTypes(self): 5086 return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self) 5087 5088 def AddHardTypeIncompatibility(self, type1, type2): 5089 r""" 5090 Incompatibilities: 5091 Two nodes with "hard" incompatible types cannot share the same route at 5092 all, while with a "temporal" incompatibility they can't be on the same 5093 route at the same time. 5094 """ 5095 return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2) 5096 5097 def AddTemporalTypeIncompatibility(self, type1, type2): 5098 return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2) 5099 5100 def GetHardTypeIncompatibilitiesOfType(self, type): 5101 r""" Returns visit types incompatible with a given type.""" 5102 return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type) 5103 5104 def GetTemporalTypeIncompatibilitiesOfType(self, type): 5105 return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type) 5106 5107 def HasHardTypeIncompatibilities(self): 5108 r""" 5109 Returns true iff any hard (resp. temporal) type incompatibilities have 5110 been added to the model. 5111 """ 5112 return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self) 5113 5114 def HasTemporalTypeIncompatibilities(self): 5115 return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self) 5116 5117 def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives): 5118 r""" 5119 Requirements: 5120 NOTE: As of 2019-04, cycles in the requirement graph are not supported, 5121 and lead to the dependent nodes being skipped if possible (otherwise 5122 the model is considered infeasible). 5123 The following functions specify that "dependent_type" requires at least 5124 one of the types in "required_type_alternatives". 5125 5126 For same-vehicle requirements, a node of dependent type type_D requires at 5127 least one node of type type_R among the required alternatives on the same 5128 route. 5129 """ 5130 return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives) 5131 5132 def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives): 5133 r""" 5134 If type_D depends on type_R when adding type_D, any node_D of type_D and 5135 VisitTypePolicy TYPE_ADDED_TO_VEHICLE or 5136 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its 5137 vehicle at the time node_D is visited. 5138 """ 5139 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives) 5140 5141 def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives): 5142 r""" 5143 The following requirements apply when visiting dependent nodes that remove 5144 their type from the route, i.e. type_R must be on the vehicle when type_D 5145 of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, 5146 TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is 5147 visited. 5148 """ 5149 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives) 5150 5151 def GetSameVehicleRequiredTypeAlternativesOfType(self, type): 5152 r""" 5153 Returns the set of same-vehicle requirement alternatives for the given 5154 type. 5155 """ 5156 return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type) 5157 5158 def GetRequiredTypeAlternativesWhenAddingType(self, type): 5159 r""" Returns the set of requirement alternatives when adding the given type.""" 5160 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type) 5161 5162 def GetRequiredTypeAlternativesWhenRemovingType(self, type): 5163 r""" Returns the set of requirement alternatives when removing the given type.""" 5164 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type) 5165 5166 def HasSameVehicleTypeRequirements(self): 5167 r""" 5168 Returns true iff any same-route (resp. temporal) type requirements have 5169 been added to the model. 5170 """ 5171 return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self) 5172 5173 def HasTemporalTypeRequirements(self): 5174 return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self) 5175 5176 def HasTypeRegulations(self): 5177 r""" 5178 Returns true iff the model has any incompatibilities or requirements set 5179 on node types. 5180 """ 5181 return _pywrapcp.RoutingModel_HasTypeRegulations(self) 5182 5183 def UnperformedPenalty(self, var_index): 5184 r""" 5185 Get the "unperformed" penalty of a node. This is only well defined if the 5186 node is only part of a single Disjunction, and that disjunction has a 5187 penalty. For forced active nodes returns max int64_t. In all other cases, 5188 this returns 0. 5189 """ 5190 return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index) 5191 5192 def UnperformedPenaltyOrValue(self, default_value, var_index): 5193 r""" 5194 Same as above except that it returns default_value instead of 0 when 5195 penalty is not well defined (default value is passed as first argument to 5196 simplify the usage of the method in a callback). 5197 """ 5198 return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index) 5199 5200 def GetDepot(self): 5201 r""" 5202 Returns the variable index of the first starting or ending node of all 5203 routes. If all routes start and end at the same node (single depot), this 5204 is the node returned. 5205 """ 5206 return _pywrapcp.RoutingModel_GetDepot(self) 5207 5208 def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles): 5209 r""" 5210 Constrains the maximum number of active vehicles, aka the number of 5211 vehicles which do not have an empty route. For instance, this can be used 5212 to limit the number of routes in the case where there are fewer drivers 5213 than vehicles and that the fleet of vehicle is heterogeneous. 5214 """ 5215 return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles) 5216 5217 def GetMaximumNumberOfActiveVehicles(self): 5218 r""" Returns the maximum number of active vehicles.""" 5219 return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self) 5220 5221 def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index): 5222 r""" 5223 Sets the cost function of the model such that the cost of a segment of a 5224 route between node 'from' and 'to' is evaluator(from, to), whatever the 5225 route or vehicle performing the route. 5226 """ 5227 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index) 5228 5229 def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle): 5230 r""" Sets the cost function for a given vehicle route.""" 5231 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle) 5232 5233 def SetFixedCostOfAllVehicles(self, cost): 5234 r""" 5235 Sets the fixed cost of all vehicle routes. It is equivalent to calling 5236 SetFixedCostOfVehicle on all vehicle routes. 5237 """ 5238 return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost) 5239 5240 def SetFixedCostOfVehicle(self, cost, vehicle): 5241 r""" Sets the fixed cost of one vehicle route.""" 5242 return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle) 5243 5244 def GetFixedCostOfVehicle(self, vehicle): 5245 r""" 5246 Returns the route fixed cost taken into account if the route of the 5247 vehicle is not empty, aka there's at least one node on the route other 5248 than the first and last nodes. 5249 """ 5250 return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle) 5251 5252 def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle): 5253 return _pywrapcp.RoutingModel_SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle) 5254 5255 def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor): 5256 r""" 5257 The following methods set the linear and quadratic cost factors of 5258 vehicles (must be positive values). The default value of these parameters 5259 is zero for all vehicles. 5260 5261 When set, the cost_ of the model will contain terms aiming at reducing the 5262 number of vehicles used in the model, by adding the following to the 5263 objective for every vehicle v: 5264 INDICATOR(v used in the model) * 5265 [linear_cost_factor_of_vehicle_[v] 5266 - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] 5267 i.e. for every used vehicle, we add the linear factor as fixed cost, and 5268 subtract the square of the route length multiplied by the quadratic 5269 factor. This second term aims at making the routes as dense as possible. 5270 5271 Sets the linear and quadratic cost factor of all vehicles. 5272 """ 5273 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor) 5274 5275 def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle): 5276 r""" Sets the linear and quadratic cost factor of the given vehicle.""" 5277 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle) 5278 5279 def GetAmortizedLinearCostFactorOfVehicles(self): 5280 return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self) 5281 5282 def GetAmortizedQuadraticCostFactorOfVehicles(self): 5283 return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self) 5284 5285 def SetVehicleUsedWhenEmpty(self, is_used, vehicle): 5286 return _pywrapcp.RoutingModel_SetVehicleUsedWhenEmpty(self, is_used, vehicle) 5287 5288 def IsVehicleUsedWhenEmpty(self, vehicle): 5289 return _pywrapcp.RoutingModel_IsVehicleUsedWhenEmpty(self, vehicle) 5290 5291 def SetFirstSolutionEvaluator(self, evaluator): 5292 r""" 5293 Gets/sets the evaluator used during the search. Only relevant when 5294 RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. 5295 Takes ownership of evaluator. 5296 """ 5297 return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator) 5298 5299 def AddLocalSearchOperator(self, ls_operator): 5300 r""" 5301 Adds a local search operator to the set of operators used to solve the 5302 vehicle routing problem. 5303 """ 5304 return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator) 5305 5306 def AddSearchMonitor(self, monitor): 5307 r""" Adds a search monitor to the search used to solve the routing model.""" 5308 return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor) 5309 5310 def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False): 5311 r""" 5312 Adds a callback called each time a solution is found during the search. 5313 This is a shortcut to creating a monitor to call the callback on 5314 AtSolution() and adding it with AddSearchMonitor. 5315 If track_unchecked_neighbors is true, the callback will also be called on 5316 AcceptUncheckedNeighbor() events, which is useful to grab solutions 5317 obtained when solver_parameters.check_solution_period > 1 (aka fastLS). 5318 """ 5319 return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors) 5320 5321 def AddVariableMinimizedByFinalizer(self, var): 5322 r""" 5323 Adds a variable to minimize in the solution finalizer. The solution 5324 finalizer is called each time a solution is found during the search and 5325 allows to instantiate secondary variables (such as dimension cumul 5326 variables). 5327 """ 5328 return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var) 5329 5330 def AddVariableMaximizedByFinalizer(self, var): 5331 r""" 5332 Adds a variable to maximize in the solution finalizer (see above for 5333 information on the solution finalizer). 5334 """ 5335 return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var) 5336 5337 def AddWeightedVariableMinimizedByFinalizer(self, var, cost): 5338 r""" 5339 Adds a variable to minimize in the solution finalizer, with a weighted 5340 priority: the higher the more priority it has. 5341 """ 5342 return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost) 5343 5344 def AddWeightedVariableMaximizedByFinalizer(self, var, cost): 5345 r""" 5346 Adds a variable to maximize in the solution finalizer, with a weighted 5347 priority: the higher the more priority it has. 5348 """ 5349 return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost) 5350 5351 def AddVariableTargetToFinalizer(self, var, target): 5352 r""" 5353 Add a variable to set the closest possible to the target value in the 5354 solution finalizer. 5355 """ 5356 return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target) 5357 5358 def AddWeightedVariableTargetToFinalizer(self, var, target, cost): 5359 r""" 5360 Same as above with a weighted priority: the higher the cost, the more 5361 priority it has to be set close to the target value. 5362 """ 5363 return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost) 5364 5365 def CloseModel(self): 5366 r""" 5367 Closes the current routing model; after this method is called, no 5368 modification to the model can be done, but RoutesToAssignment becomes 5369 available. Note that CloseModel() is automatically called by Solve() and 5370 other methods that produce solution. 5371 This is equivalent to calling 5372 CloseModelWithParameters(DefaultRoutingSearchParameters()). 5373 """ 5374 return _pywrapcp.RoutingModel_CloseModel(self) 5375 5376 def CloseModelWithParameters(self, search_parameters): 5377 r""" 5378 Same as above taking search parameters (as of 10/2015 some the parameters 5379 have to be set when closing the model). 5380 """ 5381 return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters) 5382 5383 def Solve(self, assignment=None): 5384 r""" 5385 Solves the current routing model; closes the current model. 5386 This is equivalent to calling 5387 SolveWithParameters(DefaultRoutingSearchParameters()) 5388 or 5389 SolveFromAssignmentWithParameters(assignment, 5390 DefaultRoutingSearchParameters()). 5391 """ 5392 return _pywrapcp.RoutingModel_Solve(self, assignment) 5393 5394 def SolveWithParameters(self, search_parameters, solutions=None): 5395 r""" 5396 Solves the current routing model with the given parameters. If 'solutions' 5397 is specified, it will contain the k best solutions found during the search 5398 (from worst to best, including the one returned by this method), where k 5399 corresponds to the 'number_of_solutions_to_collect' in 5400 'search_parameters'. Note that the Assignment returned by the method and 5401 the ones in solutions are owned by the underlying solver and should not be 5402 deleted. 5403 """ 5404 return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions) 5405 5406 def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None): 5407 r""" 5408 Same as above, except that if assignment is not null, it will be used as 5409 the initial solution. 5410 """ 5411 return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions) 5412 5413 def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None): 5414 r""" 5415 Same as above but will try all assignments in order as first solutions 5416 until one succeeds. 5417 """ 5418 return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions) 5419 5420 def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment): 5421 r""" 5422 Given a "source_model" and its "source_assignment", resets 5423 "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ 5424 if costs aren't homogeneous across vehicles) of "this" model, with the 5425 values set according to those in "other_assignment". 5426 The objective_element of target_assignment is set to this->cost_. 5427 """ 5428 return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment) 5429 5430 def ComputeLowerBound(self): 5431 r""" 5432 Computes a lower bound to the routing problem solving a linear assignment 5433 problem. The routing model must be closed before calling this method. 5434 Note that problems with node disjunction constraints (including optional 5435 nodes) and non-homogenous costs are not supported (the method returns 0 in 5436 these cases). 5437 """ 5438 return _pywrapcp.RoutingModel_ComputeLowerBound(self) 5439 5440 def status(self): 5441 r""" Returns the current status of the routing model.""" 5442 return _pywrapcp.RoutingModel_status(self) 5443 5444 def enable_deep_serialization(self): 5445 r""" Returns the value of the internal enable_deep_serialization_ parameter.""" 5446 return _pywrapcp.RoutingModel_enable_deep_serialization(self) 5447 5448 def ApplyLocks(self, locks): 5449 r""" 5450 Applies a lock chain to the next search. 'locks' represents an ordered 5451 vector of nodes representing a partial route which will be fixed during 5452 the next search; it will constrain next variables such that: 5453 next[locks[i]] == locks[i+1]. 5454 5455 Returns the next variable at the end of the locked chain; this variable is 5456 not locked. An assignment containing the locks can be obtained by calling 5457 PreAssignment(). 5458 """ 5459 return _pywrapcp.RoutingModel_ApplyLocks(self, locks) 5460 5461 def ApplyLocksToAllVehicles(self, locks, close_routes): 5462 r""" 5463 Applies lock chains to all vehicles to the next search, such that locks[p] 5464 is the lock chain for route p. Returns false if the locks do not contain 5465 valid routes; expects that the routes do not contain the depots, 5466 i.e. there are empty vectors in place of empty routes. 5467 If close_routes is set to true, adds the end nodes to the route of each 5468 vehicle and deactivates other nodes. 5469 An assignment containing the locks can be obtained by calling 5470 PreAssignment(). 5471 """ 5472 return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes) 5473 5474 def PreAssignment(self): 5475 r""" 5476 Returns an assignment used to fix some of the variables of the problem. 5477 In practice, this assignment locks partial routes of the problem. This 5478 can be used in the context of locking the parts of the routes which have 5479 already been driven in online routing problems. 5480 """ 5481 return _pywrapcp.RoutingModel_PreAssignment(self) 5482 5483 def MutablePreAssignment(self): 5484 return _pywrapcp.RoutingModel_MutablePreAssignment(self) 5485 5486 def WriteAssignment(self, file_name): 5487 r""" 5488 Writes the current solution to a file containing an AssignmentProto. 5489 Returns false if the file cannot be opened or if there is no current 5490 solution. 5491 """ 5492 return _pywrapcp.RoutingModel_WriteAssignment(self, file_name) 5493 5494 def ReadAssignment(self, file_name): 5495 r""" 5496 Reads an assignment from a file and returns the current solution. 5497 Returns nullptr if the file cannot be opened or if the assignment is not 5498 valid. 5499 """ 5500 return _pywrapcp.RoutingModel_ReadAssignment(self, file_name) 5501 5502 def RestoreAssignment(self, solution): 5503 r""" 5504 Restores an assignment as a solution in the routing model and returns the 5505 new solution. Returns nullptr if the assignment is not valid. 5506 """ 5507 return _pywrapcp.RoutingModel_RestoreAssignment(self, solution) 5508 5509 def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices): 5510 r""" 5511 Restores the routes as the current solution. Returns nullptr if the 5512 solution cannot be restored (routes do not contain a valid solution). Note 5513 that calling this method will run the solver to assign values to the 5514 dimension variables; this may take considerable amount of time, especially 5515 when using dimensions with slack. 5516 """ 5517 return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices) 5518 5519 def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment): 5520 r""" 5521 Fills an assignment from a specification of the routes of the 5522 vehicles. The routes are specified as lists of variable indices that 5523 appear on the routes of the vehicles. The indices of the outer vector in 5524 'routes' correspond to vehicles IDs, the inner vector contains the 5525 variable indices on the routes for the given vehicle. The inner vectors 5526 must not contain the start and end indices, as these are determined by the 5527 routing model. Sets the value of NextVars in the assignment, adding the 5528 variables to the assignment if necessary. The method does not touch other 5529 variables in the assignment. The method can only be called after the model 5530 is closed. With ignore_inactive_indices set to false, this method will 5531 fail (return nullptr) in case some of the route contain indices that are 5532 deactivated in the model; when set to true, these indices will be 5533 skipped. Returns true if routes were successfully 5534 loaded. However, such assignment still might not be a valid 5535 solution to the routing problem due to more complex constraints; 5536 it is advisible to call solver()->CheckSolution() afterwards. 5537 """ 5538 return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment) 5539 5540 def AssignmentToRoutes(self, assignment, routes): 5541 r""" 5542 Converts the solution in the given assignment to routes for all vehicles. 5543 Expects that assignment contains a valid solution (i.e. routes for all 5544 vehicles end with an end index for that vehicle). 5545 """ 5546 return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes) 5547 5548 def CompactAssignment(self, assignment): 5549 r""" 5550 Converts the solution in the given assignment to routes for all vehicles. 5551 If the returned vector is route_indices, route_indices[i][j] is the index 5552 for jth location visited on route i. Note that contrary to 5553 AssignmentToRoutes, the vectors do include start and end locations. 5554 Returns a compacted version of the given assignment, in which all vehicles 5555 with id lower or equal to some N have non-empty routes, and all vehicles 5556 with id greater than N have empty routes. Does not take ownership of the 5557 returned object. 5558 If found, the cost of the compact assignment is the same as in the 5559 original assignment and it preserves the values of 'active' variables. 5560 Returns nullptr if a compact assignment was not found. 5561 This method only works in homogenous mode, and it only swaps equivalent 5562 vehicles (vehicles with the same start and end nodes). When creating the 5563 compact assignment, the empty plan is replaced by the route assigned to 5564 the compatible vehicle with the highest id. Note that with more complex 5565 constraints on vehicle variables, this method might fail even if a compact 5566 solution exists. 5567 This method changes the vehicle and dimension variables as necessary. 5568 While compacting the solution, only basic checks on vehicle variables are 5569 performed; if one of these checks fails no attempts to repair it are made 5570 (instead, the method returns nullptr). 5571 """ 5572 return _pywrapcp.RoutingModel_CompactAssignment(self, assignment) 5573 5574 def CompactAndCheckAssignment(self, assignment): 5575 r""" 5576 Same as CompactAssignment() but also checks the validity of the final 5577 compact solution; if it is not valid, no attempts to repair it are made 5578 (instead, the method returns nullptr). 5579 """ 5580 return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment) 5581 5582 def AddToAssignment(self, var): 5583 r""" Adds an extra variable to the vehicle routing assignment.""" 5584 return _pywrapcp.RoutingModel_AddToAssignment(self, var) 5585 5586 def AddIntervalToAssignment(self, interval): 5587 return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval) 5588 5589 def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None): 5590 r""" 5591 For every dimension in the model with an optimizer in 5592 local/global_dimension_optimizers_, this method tries to pack the cumul 5593 values of the dimension, such that: 5594 - The cumul costs (span costs, soft lower and upper bound costs, etc) are 5595 minimized. 5596 - The cumuls of the ends of the routes are minimized for this given 5597 minimal cumul cost. 5598 - Given these minimal end cumuls, the route start cumuls are maximized. 5599 Returns the assignment resulting from allocating these packed cumuls with 5600 the solver, and nullptr if these cumuls could not be set by the solver. 5601 """ 5602 return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached) 5603 5604 def GetOrCreateNodeNeighborsByCostClass(self, *args): 5605 r""" 5606 *Overload 1:* 5607 Returns neighbors of all nodes for every cost class. The result is cached 5608 and is computed once. The number of neighbors considered is based on a 5609 ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum 5610 of min-neighbors node considered. 5611 5612 | 5613 5614 *Overload 2:* 5615 Returns parameters.num_neighbors neighbors of all nodes for every cost 5616 class. The result is cached and is computed once. 5617 5618 | 5619 5620 *Overload 3:* 5621 Returns parameters.num_neighbors neighbors of all nodes for every cost 5622 class. The result is cached and is computed once. 5623 """ 5624 return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args) 5625 5626 def AddLocalSearchFilter(self, filter): 5627 r""" 5628 Adds a custom local search filter to the list of filters used to speed up 5629 local search by pruning unfeasible variable assignments. 5630 Calling this method after the routing model has been closed (CloseModel() 5631 or Solve() has been called) has no effect. 5632 The routing model does not take ownership of the filter. 5633 """ 5634 return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter) 5635 5636 def Start(self, vehicle): 5637 r""" 5638 Model inspection. 5639 Returns the variable index of the starting node of a vehicle route. 5640 """ 5641 return _pywrapcp.RoutingModel_Start(self, vehicle) 5642 5643 def End(self, vehicle): 5644 r""" Returns the variable index of the ending node of a vehicle route.""" 5645 return _pywrapcp.RoutingModel_End(self, vehicle) 5646 5647 def IsStart(self, index): 5648 r""" Returns true if 'index' represents the first node of a route.""" 5649 return _pywrapcp.RoutingModel_IsStart(self, index) 5650 5651 def IsEnd(self, index): 5652 r""" Returns true if 'index' represents the last node of a route.""" 5653 return _pywrapcp.RoutingModel_IsEnd(self, index) 5654 5655 def VehicleIndex(self, index): 5656 r""" 5657 Returns the vehicle of the given start/end index, and -1 if the given 5658 index is not a vehicle start/end. 5659 """ 5660 return _pywrapcp.RoutingModel_VehicleIndex(self, index) 5661 5662 def Next(self, assignment, index): 5663 r""" 5664 Assignment inspection 5665 Returns the variable index of the node directly after the node 5666 corresponding to 'index' in 'assignment'. 5667 """ 5668 return _pywrapcp.RoutingModel_Next(self, assignment, index) 5669 5670 def IsVehicleUsed(self, assignment, vehicle): 5671 r""" Returns true if the route of 'vehicle' is non empty in 'assignment'.""" 5672 return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle) 5673 5674 def NextVar(self, index): 5675 r""" 5676 Returns the next variable of the node corresponding to index. Note that 5677 NextVar(index) == index is equivalent to ActiveVar(index) == 0. 5678 """ 5679 return _pywrapcp.RoutingModel_NextVar(self, index) 5680 5681 def ActiveVar(self, index): 5682 r""" Returns the active variable of the node corresponding to index.""" 5683 return _pywrapcp.RoutingModel_ActiveVar(self, index) 5684 5685 def ActiveVehicleVar(self, vehicle): 5686 r""" 5687 Returns the active variable of the vehicle. It will be equal to 1 iff the 5688 route of the vehicle is not empty, 0 otherwise. 5689 """ 5690 return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle) 5691 5692 def VehicleRouteConsideredVar(self, vehicle): 5693 r""" 5694 Returns the variable specifying whether or not the given vehicle route is 5695 considered for costs and constraints. It will be equal to 1 iff the route 5696 of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true. 5697 """ 5698 return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle) 5699 5700 def VehicleVar(self, index): 5701 r""" 5702 Returns the vehicle variable of the node corresponding to index. Note that 5703 VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0. 5704 """ 5705 return _pywrapcp.RoutingModel_VehicleVar(self, index) 5706 5707 def ResourceVar(self, vehicle, resource_group): 5708 r""" 5709 Returns the resource variable for the given vehicle index in the given 5710 resource group. If a vehicle doesn't require a resource from the 5711 corresponding resource group, then ResourceVar(v, r_g) == -1. 5712 """ 5713 return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group) 5714 5715 def CostVar(self): 5716 r""" Returns the global cost variable which is being minimized.""" 5717 return _pywrapcp.RoutingModel_CostVar(self) 5718 5719 def GetArcCostForVehicle(self, from_index, to_index, vehicle): 5720 r""" 5721 Returns the cost of the transit arc between two nodes for a given vehicle. 5722 Input are variable indices of node. This returns 0 if vehicle < 0. 5723 """ 5724 return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle) 5725 5726 def CostsAreHomogeneousAcrossVehicles(self): 5727 r""" Whether costs are homogeneous across all vehicles.""" 5728 return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self) 5729 5730 def GetHomogeneousCost(self, from_index, to_index): 5731 r""" 5732 Returns the cost of the segment between two nodes supposing all vehicle 5733 costs are the same (returns the cost for the first vehicle otherwise). 5734 """ 5735 return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index) 5736 5737 def GetArcCostForFirstSolution(self, from_index, to_index): 5738 r""" 5739 Returns the cost of the arc in the context of the first solution strategy. 5740 This is typically a simplification of the actual cost; see the .cc. 5741 """ 5742 return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index) 5743 5744 def GetArcCostForClass(self, from_index, to_index, cost_class_index): 5745 r""" 5746 Returns the cost of the segment between two nodes for a given cost 5747 class. Input are variable indices of nodes and the cost class. 5748 Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the 5749 returned cost won't necessarily be zero: only some of the components 5750 of the cost that depend on the cost class will be omited. See the code 5751 for details. 5752 """ 5753 return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index) 5754 5755 def GetCostClassIndexOfVehicle(self, vehicle): 5756 r""" Get the cost class index of the given vehicle.""" 5757 return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle) 5758 5759 def HasVehicleWithCostClassIndex(self, cost_class_index): 5760 r""" 5761 Returns true iff the model contains a vehicle with the given 5762 cost_class_index. 5763 """ 5764 return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index) 5765 5766 def GetCostClassesCount(self): 5767 r""" Returns the number of different cost classes in the model.""" 5768 return _pywrapcp.RoutingModel_GetCostClassesCount(self) 5769 5770 def GetNonZeroCostClassesCount(self): 5771 r""" Ditto, minus the 'always zero', built-in cost class.""" 5772 return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self) 5773 5774 def GetVehicleClassIndexOfVehicle(self, vehicle): 5775 return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle) 5776 5777 def GetVehicleOfClass(self, vehicle_class): 5778 r""" 5779 Returns a vehicle of the given vehicle class, and -1 if there are no 5780 vehicles for this class. 5781 """ 5782 return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class) 5783 5784 def GetVehicleClassesCount(self): 5785 r""" Returns the number of different vehicle classes in the model.""" 5786 return _pywrapcp.RoutingModel_GetVehicleClassesCount(self) 5787 5788 def GetSameVehicleIndicesOfIndex(self, node): 5789 r""" Returns variable indices of nodes constrained to be on the same route.""" 5790 return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node) 5791 5792 def GetVehicleTypeContainer(self): 5793 return _pywrapcp.RoutingModel_GetVehicleTypeContainer(self) 5794 5795 def ArcIsMoreConstrainedThanArc(self, _from, to1, to2): 5796 r""" 5797 Returns whether the arc from->to1 is more constrained than from->to2, 5798 taking into account, in order: 5799 - whether the destination node isn't an end node 5800 - whether the destination node is mandatory 5801 - whether the destination node is bound to the same vehicle as the source 5802 - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) 5803 It then breaks ties using, in order: 5804 - the arc cost (taking unperformed penalties into account) 5805 - the size of the vehicle vars of "to1" and "to2" (lowest size wins) 5806 - the value: the lowest value of the indices to1 and to2 wins. 5807 See the .cc for details. 5808 The more constrained arc is typically preferable when building a 5809 first solution. This method is intended to be used as a callback for the 5810 BestValueByComparisonSelector value selector. 5811 Args: 5812 from: the variable index of the source node 5813 to1: the variable index of the first candidate destination node. 5814 to2: the variable index of the second candidate destination node. 5815 """ 5816 return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2) 5817 5818 def DebugOutputAssignment(self, solution_assignment, dimension_to_print): 5819 r""" 5820 Print some debugging information about an assignment, including the 5821 feasible intervals of the CumulVar for dimension "dimension_to_print" 5822 at each step of the routes. 5823 If "dimension_to_print" is omitted, all dimensions will be printed. 5824 """ 5825 return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print) 5826 5827 def solver(self): 5828 r""" 5829 Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair 5830 containing the minimum and maximum of the CumulVar of the jth node on 5831 route i. 5832 - cumul_bounds[i][j].first is the minimum. 5833 - cumul_bounds[i][j].second is the maximum. 5834 Returns the underlying constraint solver. Can be used to add extra 5835 constraints and/or modify search algorithms. 5836 """ 5837 return _pywrapcp.RoutingModel_solver(self) 5838 5839 def CheckLimit(self, *args): 5840 r""" 5841 Returns true if the search limit has been crossed with the given time 5842 offset. 5843 """ 5844 return _pywrapcp.RoutingModel_CheckLimit(self, *args) 5845 5846 def RemainingTime(self): 5847 r""" Returns the time left in the search limit.""" 5848 return _pywrapcp.RoutingModel_RemainingTime(self) 5849 5850 def TimeBuffer(self): 5851 r""" Returns the time buffer to safely return a solution.""" 5852 return _pywrapcp.RoutingModel_TimeBuffer(self) 5853 5854 def nodes(self): 5855 r""" 5856 Sizes and indices 5857 Returns the number of nodes in the model. 5858 """ 5859 return _pywrapcp.RoutingModel_nodes(self) 5860 5861 def vehicles(self): 5862 r""" Returns the number of vehicle routes in the model.""" 5863 return _pywrapcp.RoutingModel_vehicles(self) 5864 5865 def Size(self): 5866 r""" Returns the number of next variables in the model.""" 5867 return _pywrapcp.RoutingModel_Size(self) 5868 5869 def GetNumberOfDecisionsInFirstSolution(self, search_parameters): 5870 r""" 5871 Returns statistics on first solution search, number of decisions sent to 5872 filters, number of decisions rejected by filters. 5873 """ 5874 return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters) 5875 5876 def GetNumberOfRejectsInFirstSolution(self, search_parameters): 5877 return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters) 5878 5879 def GetAutomaticFirstSolutionStrategy(self): 5880 r""" Returns the automatic first solution strategy selected.""" 5881 return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self) 5882 5883 def IsMatchingModel(self): 5884 r""" Returns true if a vehicle/node matching problem is detected.""" 5885 return _pywrapcp.RoutingModel_IsMatchingModel(self) 5886 5887 def AreRoutesInterdependent(self, parameters): 5888 r""" 5889 Returns true if routes are interdependent. This means that any 5890 modification to a route might impact another. 5891 """ 5892 return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters) 5893 5894 def MakeGuidedSlackFinalizer(self, dimension, initializer): 5895 r""" 5896 The next few members are in the public section only for testing purposes. 5897 5898 MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a 5899 dimension using a callback to choose which values to start with. 5900 The finalizer works only when all next variables in the model have 5901 been fixed. It has the following two characteristics: 5902 1. It follows the routes defined by the nexts variables when choosing a 5903 variable to make a decision on. 5904 2. When it comes to choose a value for the slack of node i, the decision 5905 builder first calls the callback with argument i, and supposingly the 5906 returned value is x it creates decisions slack[i] = x, slack[i] = x + 5907 1, slack[i] = x - 1, slack[i] = x + 2, etc. 5908 """ 5909 return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer) 5910 5911 def MakeSelfDependentDimensionFinalizer(self, dimension): 5912 r""" 5913 MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a 5914 self-dependent dimension. It makes an extensive use of the caches of the 5915 state dependent transits. 5916 In detail, MakeSelfDependentDimensionFinalizer returns a composition of a 5917 local search decision builder with a greedy descent operator for the cumul 5918 of the start of each route and a guided slack finalizer. Provided there 5919 are no time windows and the maximum slacks are large enough, once the 5920 cumul of the start of route is fixed, the guided finalizer can find 5921 optimal values of the slacks for the rest of the route in time 5922 proportional to the length of the route. Therefore the composed finalizer 5923 generally works in time O(log(t)*n*m), where t is the latest possible 5924 departute time, n is the number of nodes in the network and m is the 5925 number of vehicles. 5926 """ 5927 return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension) 5928 5929 def GetPathsMetadata(self): 5930 return _pywrapcp.RoutingModel_GetPathsMetadata(self) 5931 5932# Register RoutingModel in _pywrapcp: 5933_pywrapcp.RoutingModel_swigregister(RoutingModel) 5934cvar = _pywrapcp.cvar 5935RoutingModel.kNoPenalty = _pywrapcp.cvar.RoutingModel_kNoPenalty 5936RoutingModel.kNoDisjunction = _pywrapcp.cvar.RoutingModel_kNoDisjunction 5937RoutingModel.kNoDimension = _pywrapcp.cvar.RoutingModel_kNoDimension 5938 5939class RoutingModelVisitor(BaseObject): 5940 r""" Routing model visitor.""" 5941 5942 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5943 __repr__ = _swig_repr 5944 5945 def __init__(self): 5946 _pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor()) 5947 __swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor 5948 5949# Register RoutingModelVisitor in _pywrapcp: 5950_pywrapcp.RoutingModelVisitor_swigregister(RoutingModelVisitor) 5951RoutingModelVisitor.kLightElement = _pywrapcp.cvar.RoutingModelVisitor_kLightElement 5952RoutingModelVisitor.kLightElement2 = _pywrapcp.cvar.RoutingModelVisitor_kLightElement2 5953RoutingModelVisitor.kRemoveValues = _pywrapcp.cvar.RoutingModelVisitor_kRemoveValues 5954 5955class GlobalVehicleBreaksConstraint(Constraint): 5956 r""" 5957 GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on 5958 all vehicles in the dimension passed to its constructor. 5959 It is intended to be used for dimensions representing time. 5960 A break constraint ensures break intervals fit on the route of a vehicle. 5961 For a given vehicle, it forces break intervals to be disjoint from visit 5962 intervals, where visit intervals start at CumulVar(node) and last for 5963 node_visit_transit[node]. Moreover, it ensures that there is enough time 5964 between two consecutive nodes of a route to do transit and vehicle breaks, 5965 i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB, 5966 then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break). 5967 """ 5968 5969 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5970 __repr__ = _swig_repr 5971 5972 def __init__(self, dimension): 5973 _pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension)) 5974 5975 def DebugString(self): 5976 return _pywrapcp.GlobalVehicleBreaksConstraint_DebugString(self) 5977 5978 def Post(self): 5979 return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self) 5980 5981 def InitialPropagateWrapper(self): 5982 return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self) 5983 __swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint 5984 5985# Register GlobalVehicleBreaksConstraint in _pywrapcp: 5986_pywrapcp.GlobalVehicleBreaksConstraint_swigregister(GlobalVehicleBreaksConstraint) 5987class TypeRegulationsChecker(object): 5988 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5989 5990 def __init__(self, *args, **kwargs): 5991 raise AttributeError("No constructor defined - class is abstract") 5992 __repr__ = _swig_repr 5993 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker 5994 5995 def CheckVehicle(self, vehicle, next_accessor): 5996 return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor) 5997 5998# Register TypeRegulationsChecker in _pywrapcp: 5999_pywrapcp.TypeRegulationsChecker_swigregister(TypeRegulationsChecker) 6000class TypeIncompatibilityChecker(TypeRegulationsChecker): 6001 r""" Checker for type incompatibilities.""" 6002 6003 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6004 __repr__ = _swig_repr 6005 6006 def __init__(self, model, check_hard_incompatibilities): 6007 _pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities)) 6008 __swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker 6009 6010# Register TypeIncompatibilityChecker in _pywrapcp: 6011_pywrapcp.TypeIncompatibilityChecker_swigregister(TypeIncompatibilityChecker) 6012class TypeRequirementChecker(TypeRegulationsChecker): 6013 r""" Checker for type requirements.""" 6014 6015 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6016 __repr__ = _swig_repr 6017 6018 def __init__(self, model): 6019 _pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model)) 6020 __swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker 6021 6022# Register TypeRequirementChecker in _pywrapcp: 6023_pywrapcp.TypeRequirementChecker_swigregister(TypeRequirementChecker) 6024class TypeRegulationsConstraint(Constraint): 6025 r""" 6026 The following constraint ensures that incompatibilities and requirements 6027 between types are respected. 6028 6029 It verifies both "hard" and "temporal" incompatibilities. 6030 Two nodes with hard incompatible types cannot be served by the same vehicle 6031 at all, while with a temporal incompatibility they can't be on the same 6032 route at the same time. 6033 The VisitTypePolicy of a node determines how visiting it impacts the type 6034 count on the route. 6035 6036 For example, for 6037 - three temporally incompatible types T1 T2 and T3 6038 - 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with 6039 - a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE 6040 - r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE 6041 - 3 nodes A, UV and AR of type T3, respectively with type policies 6042 TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and 6043 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 6044 the configurations 6045 UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and 6046 a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations 6047 a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or 6048 a1 --> r1 --> UV --> ... are not feasible. 6049 6050 It also verifies same-vehicle and temporal type requirements. 6051 A node of type T_d with a same-vehicle requirement for type T_r needs to be 6052 served by the same vehicle as a node of type T_r. 6053 Temporal requirements, on the other hand, can take effect either when the 6054 dependent type is being added to the route or when it's removed from it, 6055 which is determined by the dependent node's VisitTypePolicy. 6056 In the above example: 6057 - If T3 is required on the same vehicle as T1, A, AR or UV must be on the 6058 same vehicle as a1. 6059 - If T2 is required when adding T1, a2 must be visited *before* a1, and if 6060 r2 is also visited on the route, it must be *after* a1, i.e. T2 must be on 6061 the vehicle when a1 is visited: 6062 ... --> a2 --> ... --> a1 --> ... --> r2 --> ... 6063 - If T3 is required when removing T1, T3 needs to be on the vehicle when 6064 r1 is visited: 6065 ... --> A --> ... --> r1 --> ... OR ... --> r1 --> ... --> UV --> ... 6066 """ 6067 6068 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6069 __repr__ = _swig_repr 6070 6071 def __init__(self, model): 6072 _pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model)) 6073 6074 def Post(self): 6075 return _pywrapcp.TypeRegulationsConstraint_Post(self) 6076 6077 def InitialPropagateWrapper(self): 6078 return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self) 6079 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint 6080 6081# Register TypeRegulationsConstraint in _pywrapcp: 6082_pywrapcp.TypeRegulationsConstraint_swigregister(TypeRegulationsConstraint) 6083class BoundCost(object): 6084 r""" 6085 A structure meant to store soft bounds and associated violation constants. 6086 It is 'Simple' because it has one BoundCost per element, 6087 in contrast to 'Multiple'. Design notes: 6088 - it is meant to store model information to be shared through pointers, 6089 so it disallows copy and assign to avoid accidental duplication. 6090 - it keeps soft bounds as an array of structs to help cache, 6091 because code that uses such bounds typically use both bound and cost. 6092 - soft bounds are named pairs, prevents some mistakes. 6093 - using operator[] to access elements is not interesting, 6094 because the structure will be accessed through pointers, moreover having 6095 to type bound_cost reminds the user of the order if they do a copy 6096 assignment of the element. 6097 """ 6098 6099 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6100 __repr__ = _swig_repr 6101 bound = property(_pywrapcp.BoundCost_bound_get, _pywrapcp.BoundCost_bound_set) 6102 cost = property(_pywrapcp.BoundCost_cost_get, _pywrapcp.BoundCost_cost_set) 6103 6104 def __init__(self, *args): 6105 _pywrapcp.BoundCost_swiginit(self, _pywrapcp.new_BoundCost(*args)) 6106 __swig_destroy__ = _pywrapcp.delete_BoundCost 6107 6108# Register BoundCost in _pywrapcp: 6109_pywrapcp.BoundCost_swigregister(BoundCost) 6110class SimpleBoundCosts(object): 6111 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6112 __repr__ = _swig_repr 6113 6114 def __init__(self, num_bounds, default_bound_cost): 6115 _pywrapcp.SimpleBoundCosts_swiginit(self, _pywrapcp.new_SimpleBoundCosts(num_bounds, default_bound_cost)) 6116 6117 def bound_cost(self, element): 6118 return _pywrapcp.SimpleBoundCosts_bound_cost(self, element) 6119 6120 def size(self): 6121 return _pywrapcp.SimpleBoundCosts_size(self) 6122 __swig_destroy__ = _pywrapcp.delete_SimpleBoundCosts 6123 6124# Register SimpleBoundCosts in _pywrapcp: 6125_pywrapcp.SimpleBoundCosts_swigregister(SimpleBoundCosts) 6126class RoutingDimension(object): 6127 r""" 6128 Dimensions represent quantities accumulated at nodes along the routes. They 6129 represent quantities such as weights or volumes carried along the route, or 6130 distance or times. 6131 6132 Quantities at a node are represented by "cumul" variables and the increase 6133 or decrease of quantities between nodes are represented by "transit" 6134 variables. These variables are linked as follows: 6135 6136 if j == next(i), 6137 cumuls(j) = cumuls(i) + transits(i) + slacks(i) + 6138 state_dependent_transits(i) 6139 6140 where slack is a positive slack variable (can represent waiting times for 6141 a time dimension), and state_dependent_transits is a non-purely functional 6142 version of transits_. Favour transits over state_dependent_transits when 6143 possible, because purely functional callbacks allow more optimisations and 6144 make the model faster and easier to solve. 6145 for a given vehicle, it is passed as an external vector, it would be better 6146 to have this information here. 6147 """ 6148 6149 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6150 6151 def __init__(self, *args, **kwargs): 6152 raise AttributeError("No constructor defined") 6153 __repr__ = _swig_repr 6154 __swig_destroy__ = _pywrapcp.delete_RoutingDimension 6155 6156 def model(self): 6157 r""" Returns the model on which the dimension was created.""" 6158 return _pywrapcp.RoutingDimension_model(self) 6159 6160 def GetTransitValue(self, from_index, to_index, vehicle): 6161 r""" 6162 Returns the transition value for a given pair of nodes (as var index); 6163 this value is the one taken by the corresponding transit variable when 6164 the 'next' variable for 'from_index' is bound to 'to_index'. 6165 """ 6166 return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle) 6167 6168 def GetTransitValueFromClass(self, from_index, to_index, vehicle_class): 6169 r""" 6170 Same as above but taking a vehicle class of the dimension instead of a 6171 vehicle (the class of a vehicle can be obtained with vehicle_to_class()). 6172 """ 6173 return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class) 6174 6175 def CumulVar(self, index): 6176 r""" 6177 Get the cumul, transit and slack variables for the given node (given as 6178 int64_t var index). 6179 """ 6180 return _pywrapcp.RoutingDimension_CumulVar(self, index) 6181 6182 def TransitVar(self, index): 6183 return _pywrapcp.RoutingDimension_TransitVar(self, index) 6184 6185 def FixedTransitVar(self, index): 6186 return _pywrapcp.RoutingDimension_FixedTransitVar(self, index) 6187 6188 def SlackVar(self, index): 6189 return _pywrapcp.RoutingDimension_SlackVar(self, index) 6190 6191 def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle): 6192 r""" 6193 Sets an upper bound on the dimension span on a given vehicle. This is the 6194 preferred way to limit the "length" of the route of a vehicle according to 6195 a dimension. 6196 """ 6197 return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle) 6198 6199 def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle): 6200 r""" 6201 Sets a cost proportional to the dimension span on a given vehicle, 6202 or on all vehicles at once. "coefficient" must be nonnegative. 6203 This is handy to model costs proportional to idle time when the dimension 6204 represents time. 6205 The cost for a vehicle is 6206 span_cost = coefficient * (dimension end value - dimension start value). 6207 """ 6208 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle) 6209 6210 def SetSpanCostCoefficientForAllVehicles(self, coefficient): 6211 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient) 6212 6213 def SetGlobalSpanCostCoefficient(self, coefficient): 6214 r""" 6215 Sets a cost proportional to the *global* dimension span, that is the 6216 difference between the largest value of route end cumul variables and 6217 the smallest value of route start cumul variables. 6218 In other words: 6219 global_span_cost = 6220 coefficient * (Max(dimension end value) - Min(dimension start value)). 6221 """ 6222 return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient) 6223 6224 def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient): 6225 r""" 6226 Sets a soft upper bound to the cumul variable of a given variable index. 6227 If the value of the cumul variable is greater than the bound, a cost 6228 proportional to the difference between this value and the bound is added 6229 to the cost function of the model: 6230 cumulVar <= upper_bound -> cost = 0 6231 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) 6232 This is also handy to model tardiness costs when the dimension represents 6233 time. 6234 """ 6235 return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient) 6236 6237 def HasCumulVarSoftUpperBound(self, index): 6238 r""" 6239 Returns true if a soft upper bound has been set for a given variable 6240 index. 6241 """ 6242 return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index) 6243 6244 def GetCumulVarSoftUpperBound(self, index): 6245 r""" 6246 Returns the soft upper bound of a cumul variable for a given variable 6247 index. The "hard" upper bound of the variable is returned if no soft upper 6248 bound has been set. 6249 """ 6250 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index) 6251 6252 def GetCumulVarSoftUpperBoundCoefficient(self, index): 6253 r""" 6254 Returns the cost coefficient of the soft upper bound of a cumul variable 6255 for a given variable index. If no soft upper bound has been set, 0 is 6256 returned. 6257 """ 6258 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index) 6259 6260 def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient): 6261 r""" 6262 Sets a soft lower bound to the cumul variable of a given variable index. 6263 If the value of the cumul variable is less than the bound, a cost 6264 proportional to the difference between this value and the bound is added 6265 to the cost function of the model: 6266 cumulVar > lower_bound -> cost = 0 6267 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - 6268 cumulVar). 6269 This is also handy to model earliness costs when the dimension represents 6270 time. 6271 """ 6272 return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient) 6273 6274 def HasCumulVarSoftLowerBound(self, index): 6275 r""" 6276 Returns true if a soft lower bound has been set for a given variable 6277 index. 6278 """ 6279 return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index) 6280 6281 def GetCumulVarSoftLowerBound(self, index): 6282 r""" 6283 Returns the soft lower bound of a cumul variable for a given variable 6284 index. The "hard" lower bound of the variable is returned if no soft lower 6285 bound has been set. 6286 """ 6287 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index) 6288 6289 def GetCumulVarSoftLowerBoundCoefficient(self, index): 6290 r""" 6291 Returns the cost coefficient of the soft lower bound of a cumul variable 6292 for a given variable index. If no soft lower bound has been set, 0 is 6293 returned. 6294 """ 6295 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index) 6296 6297 def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits): 6298 r""" 6299 Sets the breaks for a given vehicle. Breaks are represented by 6300 IntervalVars. They may interrupt transits between nodes and increase 6301 the value of corresponding slack variables. 6302 A break may take place before the start of a vehicle, after the end of 6303 a vehicle, or during a travel i -> j. 6304 6305 In that case, the interval [break.Start(), break.End()) must be a subset 6306 of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In 6307 other words, a break may not overlap any node n's visit, given by 6308 [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). 6309 This formula considers post_travel(_, start) and pre_travel(end, _) to be 6310 0; pre_travel will never be called on any (_, start) and post_travel will 6311 never we called on any (end, _). If pre_travel_evaluator or 6312 post_travel_evaluator is -1, it will be taken as a function that always 6313 returns 0. 6314 Deprecated, sets pre_travel(i, j) = node_visit_transit[i]. 6315 """ 6316 return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits) 6317 6318 def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle): 6319 r""" 6320 With breaks supposed to be consecutive, this forces the distance between 6321 breaks of size at least minimum_break_duration to be at most distance. 6322 This supposes that the time until route start and after route end are 6323 infinite breaks. 6324 """ 6325 return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle) 6326 6327 def InitializeBreaks(self): 6328 r""" 6329 Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, 6330 pre_travel_evaluators and post_travel_evaluators. 6331 """ 6332 return _pywrapcp.RoutingDimension_InitializeBreaks(self) 6333 6334 def HasBreakConstraints(self): 6335 r""" Returns true if any break interval or break distance was defined.""" 6336 return _pywrapcp.RoutingDimension_HasBreakConstraints(self) 6337 6338 def GetPreTravelEvaluatorOfVehicle(self, vehicle): 6339 return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle) 6340 6341 def GetPostTravelEvaluatorOfVehicle(self, vehicle): 6342 return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle) 6343 6344 def base_dimension(self): 6345 r""" Returns the parent in the dependency tree if any or nullptr otherwise.""" 6346 return _pywrapcp.RoutingDimension_base_dimension(self) 6347 6348 def ShortestTransitionSlack(self, node): 6349 r""" 6350 It makes sense to use the function only for self-dependent dimension. 6351 For such dimensions the value of the slack of a node determines the 6352 transition cost of the next transit. Provided that 6353 1. cumul[node] is fixed, 6354 2. next[node] and next[next[node]] (if exists) are fixed, 6355 the value of slack[node] for which cumul[next[node]] + transit[next[node]] 6356 is minimized can be found in O(1) using this function. 6357 """ 6358 return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node) 6359 6360 def name(self): 6361 r""" Returns the name of the dimension.""" 6362 return _pywrapcp.RoutingDimension_name(self) 6363 6364 def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index): 6365 return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index) 6366 6367 def HasPickupToDeliveryLimits(self): 6368 return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self) 6369 6370 def AddNodePrecedence(self, first_node, second_node, offset): 6371 return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset) 6372 6373 def GetSpanUpperBoundForVehicle(self, vehicle): 6374 return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle) 6375 6376 def GetSpanCostCoefficientForVehicle(self, vehicle): 6377 return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle) 6378 6379 def global_span_cost_coefficient(self): 6380 return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self) 6381 6382 def GetGlobalOptimizerOffset(self): 6383 return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self) 6384 6385 def GetLocalOptimizerOffsetForVehicle(self, vehicle): 6386 return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle) 6387 6388 def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6389 r""" 6390 If the span of vehicle on this dimension is larger than bound, 6391 the cost will be increased by cost * (span - bound). 6392 """ 6393 return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6394 6395 def HasSoftSpanUpperBounds(self): 6396 return _pywrapcp.RoutingDimension_HasSoftSpanUpperBounds(self) 6397 6398 def GetSoftSpanUpperBoundForVehicle(self, vehicle): 6399 return _pywrapcp.RoutingDimension_GetSoftSpanUpperBoundForVehicle(self, vehicle) 6400 6401 def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6402 r""" 6403 If the span of vehicle on this dimension is larger than bound, 6404 the cost will be increased by cost * (span - bound)^2. 6405 """ 6406 return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6407 6408 def HasQuadraticCostSoftSpanUpperBounds(self): 6409 return _pywrapcp.RoutingDimension_HasQuadraticCostSoftSpanUpperBounds(self) 6410 6411 def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle): 6412 return _pywrapcp.RoutingDimension_GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle) 6413 6414# Register RoutingDimension in _pywrapcp: 6415_pywrapcp.RoutingDimension_swigregister(RoutingDimension) 6416 6417def SolveModelWithSat(model, search_parameters, initial_solution, solution): 6418 r""" 6419 Attempts to solve the model using the cp-sat solver. As of 5/2019, will 6420 solve the TSP corresponding to the model if it has a single vehicle. 6421 Therefore the resulting solution might not actually be feasible. Will return 6422 false if a solution could not be found. 6423 """ 6424 return _pywrapcp.SolveModelWithSat(model, search_parameters, initial_solution, solution)
class
DefaultPhaseParameters:
64class DefaultPhaseParameters(object): 65 r""" 66 This struct holds all parameters for the default search. 67 DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. 68 Note this is for advanced users only. 69 """ 70 71 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 72 __repr__ = _swig_repr 73 CHOOSE_MAX_SUM_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_SUM_IMPACT 74 CHOOSE_MAX_AVERAGE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_AVERAGE_IMPACT 75 CHOOSE_MAX_VALUE_IMPACT = _pywrapcp.DefaultPhaseParameters_CHOOSE_MAX_VALUE_IMPACT 76 SELECT_MIN_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MIN_IMPACT 77 SELECT_MAX_IMPACT = _pywrapcp.DefaultPhaseParameters_SELECT_MAX_IMPACT 78 NONE = _pywrapcp.DefaultPhaseParameters_NONE 79 NORMAL = _pywrapcp.DefaultPhaseParameters_NORMAL 80 VERBOSE = _pywrapcp.DefaultPhaseParameters_VERBOSE 81 var_selection_schema = property(_pywrapcp.DefaultPhaseParameters_var_selection_schema_get, _pywrapcp.DefaultPhaseParameters_var_selection_schema_set, doc=r""" 82 This parameter describes how the next variable to instantiate 83 will be chosen. 84 """) 85 value_selection_schema = property(_pywrapcp.DefaultPhaseParameters_value_selection_schema_get, _pywrapcp.DefaultPhaseParameters_value_selection_schema_set, doc=r""" This parameter describes which value to select for a given var.""") 86 initialization_splits = property(_pywrapcp.DefaultPhaseParameters_initialization_splits_get, _pywrapcp.DefaultPhaseParameters_initialization_splits_set, doc=r""" 87 Maximum number of intervals that the initialization of impacts will scan 88 per variable. 89 """) 90 run_all_heuristics = property(_pywrapcp.DefaultPhaseParameters_run_all_heuristics_get, _pywrapcp.DefaultPhaseParameters_run_all_heuristics_set, doc=r""" 91 The default phase will run heuristics periodically. This parameter 92 indicates if we should run all heuristics, or a randomly selected 93 one. 94 """) 95 heuristic_period = property(_pywrapcp.DefaultPhaseParameters_heuristic_period_get, _pywrapcp.DefaultPhaseParameters_heuristic_period_set, doc=r""" 96 The distance in nodes between each run of the heuristics. A 97 negative or null value will mean that we will not run heuristics 98 at all. 99 """) 100 heuristic_num_failures_limit = property(_pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_get, _pywrapcp.DefaultPhaseParameters_heuristic_num_failures_limit_set, doc=r""" The failure limit for each heuristic that we run.""") 101 persistent_impact = property(_pywrapcp.DefaultPhaseParameters_persistent_impact_get, _pywrapcp.DefaultPhaseParameters_persistent_impact_set, doc=r""" 102 Whether to keep the impact from the first search for other searches, 103 or to recompute the impact for each new search. 104 """) 105 random_seed = property(_pywrapcp.DefaultPhaseParameters_random_seed_get, _pywrapcp.DefaultPhaseParameters_random_seed_set, doc=r""" Seed used to initialize the random part in some heuristics.""") 106 display_level = property(_pywrapcp.DefaultPhaseParameters_display_level_get, _pywrapcp.DefaultPhaseParameters_display_level_set, doc=r""" 107 This represents the amount of information displayed by the default search. 108 NONE means no display, VERBOSE means extra information. 109 """) 110 decision_builder = property(_pywrapcp.DefaultPhaseParameters_decision_builder_get, _pywrapcp.DefaultPhaseParameters_decision_builder_set, doc=r""" When defined, this overrides the default impact based decision builder.""") 111 112 def __init__(self): 113 _pywrapcp.DefaultPhaseParameters_swiginit(self, _pywrapcp.new_DefaultPhaseParameters()) 114 __swig_destroy__ = _pywrapcp.delete_DefaultPhaseParameters
This struct holds all parameters for the default search. DefaultPhaseParameters is only used by Solver::MakeDefaultPhase methods. Note this is for advanced users only.
initialization_splits
Maximum number of intervals that the initialization of impacts will scan per variable.
run_all_heuristics
The default phase will run heuristics periodically. This parameter indicates if we should run all heuristics, or a randomly selected one.
heuristic_period
The distance in nodes between each run of the heuristics. A negative or null value will mean that we will not run heuristics at all.
persistent_impact
Whether to keep the impact from the first search for other searches, or to recompute the impact for each new search.
class
Solver:
118class Solver(object): 119 r""" 120 Solver Class 121 122 A solver represents the main computation engine. It implements the entire 123 range of Constraint Programming protocols: 124 - Reversibility 125 - Propagation 126 - Search 127 128 Usually, Constraint Programming code consists of 129 - the creation of the Solver, 130 - the creation of the decision variables of the model, 131 - the creation of the constraints of the model and their addition to the 132 solver() through the AddConstraint() method, 133 - the creation of the main DecisionBuilder class, 134 - the launch of the solve() method with the decision builder. 135 136 For the time being, Solver is neither MT_SAFE nor MT_HOT. 137 """ 138 139 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 140 __repr__ = _swig_repr 141 INT_VAR_DEFAULT = _pywrapcp.Solver_INT_VAR_DEFAULT 142 r""" The default behavior is CHOOSE_FIRST_UNBOUND.""" 143 INT_VAR_SIMPLE = _pywrapcp.Solver_INT_VAR_SIMPLE 144 r""" The simple selection is CHOOSE_FIRST_UNBOUND.""" 145 CHOOSE_FIRST_UNBOUND = _pywrapcp.Solver_CHOOSE_FIRST_UNBOUND 146 r""" 147 Select the first unbound variable. 148 Variables are considered in the order of the vector of IntVars used 149 to create the selector. 150 """ 151 CHOOSE_RANDOM = _pywrapcp.Solver_CHOOSE_RANDOM 152 r""" Randomly select one of the remaining unbound variables.""" 153 CHOOSE_MIN_SIZE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MIN 154 r""" 155 Among unbound variables, select the variable with the smallest size, 156 i.e., the smallest number of possible values. 157 In case of a tie, the selected variables is the one with the lowest min 158 value. 159 In case of a tie, the first one is selected, first being defined by the 160 order in the vector of IntVars used to create the selector. 161 """ 162 CHOOSE_MIN_SIZE_HIGHEST_MIN = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MIN 163 r""" 164 Among unbound variables, select the variable with the smallest size, 165 i.e., the smallest number of possible values. 166 In case of a tie, the selected variable is the one with the highest min 167 value. 168 In case of a tie, the first one is selected, first being defined by the 169 order in the vector of IntVars used to create the selector. 170 """ 171 CHOOSE_MIN_SIZE_LOWEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_LOWEST_MAX 172 r""" 173 Among unbound variables, select the variable with the smallest size, 174 i.e., the smallest number of possible values. 175 In case of a tie, the selected variables is the one with the lowest max 176 value. 177 In case of a tie, the first one is selected, first being defined by the 178 order in the vector of IntVars used to create the selector. 179 """ 180 CHOOSE_MIN_SIZE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_MIN_SIZE_HIGHEST_MAX 181 r""" 182 Among unbound variables, select the variable with the smallest size, 183 i.e., the smallest number of possible values. 184 In case of a tie, the selected variable is the one with the highest max 185 value. 186 In case of a tie, the first one is selected, first being defined by the 187 order in the vector of IntVars used to create the selector. 188 """ 189 CHOOSE_LOWEST_MIN = _pywrapcp.Solver_CHOOSE_LOWEST_MIN 190 r""" 191 Among unbound variables, select the variable with the smallest minimal 192 value. 193 In case of a tie, the first one is selected, "first" defined by the 194 order in the vector of IntVars used to create the selector. 195 """ 196 CHOOSE_HIGHEST_MAX = _pywrapcp.Solver_CHOOSE_HIGHEST_MAX 197 r""" 198 Among unbound variables, select the variable with the highest maximal 199 value. 200 In case of a tie, the first one is selected, first being defined by the 201 order in the vector of IntVars used to create the selector. 202 """ 203 CHOOSE_MIN_SIZE = _pywrapcp.Solver_CHOOSE_MIN_SIZE 204 r""" 205 Among unbound variables, select the variable with the smallest size. 206 In case of a tie, the first one is selected, first being defined by the 207 order in the vector of IntVars used to create the selector. 208 """ 209 CHOOSE_MAX_SIZE = _pywrapcp.Solver_CHOOSE_MAX_SIZE 210 r""" 211 Among unbound variables, select the variable with the highest size. 212 In case of a tie, the first one is selected, first being defined by the 213 order in the vector of IntVars used to create the selector. 214 """ 215 CHOOSE_MAX_REGRET_ON_MIN = _pywrapcp.Solver_CHOOSE_MAX_REGRET_ON_MIN 216 r""" 217 Among unbound variables, select the variable with the largest 218 gap between the first and the second values of the domain. 219 """ 220 CHOOSE_PATH = _pywrapcp.Solver_CHOOSE_PATH 221 r""" 222 Selects the next unbound variable on a path, the path being defined by 223 the variables: var[i] corresponds to the index of the next of i. 224 """ 225 INT_VALUE_DEFAULT = _pywrapcp.Solver_INT_VALUE_DEFAULT 226 r""" The default behavior is ASSIGN_MIN_VALUE.""" 227 INT_VALUE_SIMPLE = _pywrapcp.Solver_INT_VALUE_SIMPLE 228 r""" The simple selection is ASSIGN_MIN_VALUE.""" 229 ASSIGN_MIN_VALUE = _pywrapcp.Solver_ASSIGN_MIN_VALUE 230 r""" Selects the min value of the selected variable.""" 231 ASSIGN_MAX_VALUE = _pywrapcp.Solver_ASSIGN_MAX_VALUE 232 r""" Selects the max value of the selected variable.""" 233 ASSIGN_RANDOM_VALUE = _pywrapcp.Solver_ASSIGN_RANDOM_VALUE 234 r""" Selects randomly one of the possible values of the selected variable.""" 235 ASSIGN_CENTER_VALUE = _pywrapcp.Solver_ASSIGN_CENTER_VALUE 236 r""" 237 Selects the first possible value which is the closest to the center 238 of the domain of the selected variable. 239 The center is defined as (min + max) / 2. 240 """ 241 SPLIT_LOWER_HALF = _pywrapcp.Solver_SPLIT_LOWER_HALF 242 r""" 243 Split the domain in two around the center, and choose the lower 244 part first. 245 """ 246 SPLIT_UPPER_HALF = _pywrapcp.Solver_SPLIT_UPPER_HALF 247 r""" 248 Split the domain in two around the center, and choose the lower 249 part first. 250 """ 251 SEQUENCE_DEFAULT = _pywrapcp.Solver_SEQUENCE_DEFAULT 252 SEQUENCE_SIMPLE = _pywrapcp.Solver_SEQUENCE_SIMPLE 253 CHOOSE_MIN_SLACK_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_MIN_SLACK_RANK_FORWARD 254 CHOOSE_RANDOM_RANK_FORWARD = _pywrapcp.Solver_CHOOSE_RANDOM_RANK_FORWARD 255 INTERVAL_DEFAULT = _pywrapcp.Solver_INTERVAL_DEFAULT 256 r""" The default is INTERVAL_SET_TIMES_FORWARD.""" 257 INTERVAL_SIMPLE = _pywrapcp.Solver_INTERVAL_SIMPLE 258 r""" The simple is INTERVAL_SET_TIMES_FORWARD.""" 259 INTERVAL_SET_TIMES_FORWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_FORWARD 260 r""" 261 Selects the variable with the lowest starting time of all variables, 262 and fixes its starting time to this lowest value. 263 """ 264 INTERVAL_SET_TIMES_BACKWARD = _pywrapcp.Solver_INTERVAL_SET_TIMES_BACKWARD 265 r""" 266 Selects the variable with the highest ending time of all variables, 267 and fixes the ending time to this highest values. 268 """ 269 TWOOPT = _pywrapcp.Solver_TWOOPT 270 r""" 271 Operator which reverses a sub-chain of a path. It is called TwoOpt 272 because it breaks two arcs on the path; resulting paths are called 273 two-optimal. 274 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 275 (where (1, 5) are first and last nodes of the path and can therefore not 276 be moved): 277 1 -> [3 -> 2] -> 4 -> 5 278 1 -> [4 -> 3 -> 2] -> 5 279 1 -> 2 -> [4 -> 3] -> 5 280 """ 281 OROPT = _pywrapcp.Solver_OROPT 282 r""" 283 Relocate: OROPT and RELOCATE. 284 Operator which moves a sub-chain of a path to another position; the 285 specified chain length is the fixed length of the chains being moved. 286 When this length is 1, the operator simply moves a node to another 287 position. 288 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain 289 length of 2 (where (1, 5) are first and last nodes of the path and can 290 therefore not be moved): 291 1 -> 4 -> [2 -> 3] -> 5 292 1 -> [3 -> 4] -> 2 -> 5 293 294 Using Relocate with chain lengths of 1, 2 and 3 together is equivalent 295 to the OrOpt operator on a path. The OrOpt operator is a limited 296 version of 3Opt (breaks 3 arcs on a path). 297 """ 298 RELOCATE = _pywrapcp.Solver_RELOCATE 299 r""" Relocate neighborhood with length of 1 (see OROPT comment).""" 300 EXCHANGE = _pywrapcp.Solver_EXCHANGE 301 r""" 302 Operator which exchanges the positions of two nodes. 303 Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 304 (where (1, 5) are first and last nodes of the path and can therefore not 305 be moved): 306 1 -> [3] -> [2] -> 4 -> 5 307 1 -> [4] -> 3 -> [2] -> 5 308 1 -> 2 -> [4] -> [3] -> 5 309 """ 310 CROSS = _pywrapcp.Solver_CROSS 311 r""" 312 Operator which cross exchanges the starting chains of 2 paths, including 313 exchanging the whole paths. 314 First and last nodes are not moved. 315 Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 316 (where (1, 5) and (6, 8) are first and last nodes of the paths and can 317 therefore not be moved): 318 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 319 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 320 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8 321 """ 322 MAKEACTIVE = _pywrapcp.Solver_MAKEACTIVE 323 r""" 324 Operator which inserts an inactive node into a path. 325 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 326 (where 1 and 4 are first and last nodes of the path) are: 327 1 -> [5] -> 2 -> 3 -> 4 328 1 -> 2 -> [5] -> 3 -> 4 329 1 -> 2 -> 3 -> [5] -> 4 330 """ 331 MAKEINACTIVE = _pywrapcp.Solver_MAKEINACTIVE 332 r""" 333 Operator which makes path nodes inactive. 334 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 335 first and last nodes of the path) are: 336 1 -> 3 -> 4 with 2 inactive 337 1 -> 2 -> 4 with 3 inactive 338 """ 339 MAKECHAININACTIVE = _pywrapcp.Solver_MAKECHAININACTIVE 340 r""" 341 Operator which makes a "chain" of path nodes inactive. 342 Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are 343 first and last nodes of the path) are: 344 1 -> 3 -> 4 with 2 inactive 345 1 -> 2 -> 4 with 3 inactive 346 1 -> 4 with 2 and 3 inactive 347 """ 348 SWAPACTIVE = _pywrapcp.Solver_SWAPACTIVE 349 r""" 350 Operator which replaces an active node by an inactive one. 351 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 352 (where 1 and 4 are first and last nodes of the path) are: 353 1 -> [5] -> 3 -> 4 with 2 inactive 354 1 -> 2 -> [5] -> 4 with 3 inactive 355 """ 356 EXTENDEDSWAPACTIVE = _pywrapcp.Solver_EXTENDEDSWAPACTIVE 357 r""" 358 Operator which makes an inactive node active and an active one inactive. 359 It is similar to SwapActiveOperator except that it tries to insert the 360 inactive node in all possible positions instead of just the position of 361 the node made inactive. 362 Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive 363 (where 1 and 4 are first and last nodes of the path) are: 364 1 -> [5] -> 3 -> 4 with 2 inactive 365 1 -> 3 -> [5] -> 4 with 2 inactive 366 1 -> [5] -> 2 -> 4 with 3 inactive 367 1 -> 2 -> [5] -> 4 with 3 inactive 368 """ 369 PATHLNS = _pywrapcp.Solver_PATHLNS 370 r""" 371 Operator which relaxes two sub-chains of three consecutive arcs each. 372 Each sub-chain is defined by a start node and the next three arcs. Those 373 six arcs are relaxed to build a new neighbor. 374 PATHLNS explores all possible pairs of starting nodes and so defines 375 n^2 neighbors, n being the number of nodes. 376 Note that the two sub-chains can be part of the same path; they even may 377 overlap. 378 """ 379 FULLPATHLNS = _pywrapcp.Solver_FULLPATHLNS 380 r""" 381 Operator which relaxes one entire path and all inactive nodes, thus 382 defining num_paths neighbors. 383 """ 384 UNACTIVELNS = _pywrapcp.Solver_UNACTIVELNS 385 r""" 386 Operator which relaxes all inactive nodes and one sub-chain of six 387 consecutive arcs. That way the path can be improved by inserting 388 inactive nodes or swapping arcs. 389 """ 390 INCREMENT = _pywrapcp.Solver_INCREMENT 391 r""" 392 Operator which defines one neighbor per variable. Each neighbor tries to 393 increment by one the value of the corresponding variable. When a new 394 solution is found the neighborhood is rebuilt from scratch, i.e., tries 395 to increment values in the variable order. 396 Consider for instance variables x and y. x is incremented one by one to 397 its max, and when it is not possible to increment x anymore, y is 398 incremented once. If this is a solution, then next neighbor tries to 399 increment x. 400 """ 401 DECREMENT = _pywrapcp.Solver_DECREMENT 402 r""" 403 Operator which defines a neighborhood to decrement values. 404 The behavior is the same as INCREMENT, except values are decremented 405 instead of incremented. 406 """ 407 SIMPLELNS = _pywrapcp.Solver_SIMPLELNS 408 r""" 409 Operator which defines one neighbor per variable. Each neighbor relaxes 410 one variable. 411 When a new solution is found the neighborhood is rebuilt from scratch. 412 Consider for instance variables x and y. First x is relaxed and the 413 solver is looking for the best possible solution (with only x relaxed). 414 Then y is relaxed, and the solver is looking for a new solution. 415 If a new solution is found, then the next variable to be relaxed is x. 416 """ 417 GE = _pywrapcp.Solver_GE 418 r""" Move is accepted when the current objective value >= objective.Min.""" 419 LE = _pywrapcp.Solver_LE 420 r""" Move is accepted when the current objective value <= objective.Max.""" 421 EQ = _pywrapcp.Solver_EQ 422 r""" 423 Move is accepted when the current objective value is in the interval 424 objective.Min .. objective.Max. 425 """ 426 DELAYED_PRIORITY = _pywrapcp.Solver_DELAYED_PRIORITY 427 r""" 428 DELAYED_PRIORITY is the lowest priority: Demons will be processed after 429 VAR_PRIORITY and NORMAL_PRIORITY demons. 430 """ 431 VAR_PRIORITY = _pywrapcp.Solver_VAR_PRIORITY 432 r""" VAR_PRIORITY is between DELAYED_PRIORITY and NORMAL_PRIORITY.""" 433 NORMAL_PRIORITY = _pywrapcp.Solver_NORMAL_PRIORITY 434 r""" NORMAL_PRIORITY is the highest priority: Demons will be processed first.""" 435 436 def __init__(self, *args): 437 _pywrapcp.Solver_swiginit(self, _pywrapcp.new_Solver(*args)) 438 439 self.__python_constraints = [] 440 441 442 443 __swig_destroy__ = _pywrapcp.delete_Solver 444 445 def Parameters(self): 446 r""" Stored Parameters.""" 447 return _pywrapcp.Solver_Parameters(self) 448 449 @staticmethod 450 def DefaultSolverParameters(): 451 r""" Create a ConstraintSolverParameters proto with all the default values.""" 452 return _pywrapcp.Solver_DefaultSolverParameters() 453 454 def AddConstraint(self, c): 455 r""" 456 Adds the constraint 'c' to the model. 457 458 After calling this method, and until there is a backtrack that undoes the 459 addition, any assignment of variables to values must satisfy the given 460 constraint in order to be considered feasible. There are two fairly 461 different use cases: 462 463 - the most common use case is modeling: the given constraint is really 464 part of the problem that the user is trying to solve. In this use case, 465 AddConstraint is called outside of search (i.e., with state() == 466 OUTSIDE_SEARCH). Most users should only use AddConstraint in this 467 way. In this case, the constraint will belong to the model forever: it 468 cannot be removed by backtracking. 469 470 - a rarer use case is that 'c' is not a real constraint of the model. It 471 may be a constraint generated by a branching decision (a constraint whose 472 goal is to restrict the search space), a symmetry breaking constraint (a 473 constraint that does restrict the search space, but in a way that cannot 474 have an impact on the quality of the solutions in the subtree), or an 475 inferred constraint that, while having no semantic value to the model (it 476 does not restrict the set of solutions), is worth having because we 477 believe it may strengthen the propagation. In these cases, it happens 478 that the constraint is added during the search (i.e., with state() == 479 IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is 480 added during a search, it applies only to the subtree of the search tree 481 rooted at the current node, and will be automatically removed by 482 backtracking. 483 484 This method does not take ownership of the constraint. If the constraint 485 has been created by any factory method (Solver::MakeXXX), it will 486 automatically be deleted. However, power users who implement their own 487 constraints should do: solver.AddConstraint(solver.RevAlloc(new 488 MyConstraint(...)); 489 """ 490 return _pywrapcp.Solver_AddConstraint(self, c) 491 492 def Solve(self, *args): 493 return _pywrapcp.Solver_Solve(self, *args) 494 495 def NewSearch(self, *args): 496 return _pywrapcp.Solver_NewSearch(self, *args) 497 498 def NextSolution(self): 499 return _pywrapcp.Solver_NextSolution(self) 500 501 def RestartSearch(self): 502 return _pywrapcp.Solver_RestartSearch(self) 503 504 def EndSearch(self): 505 return _pywrapcp.Solver_EndSearch(self) 506 507 def SolveAndCommit(self, *args): 508 return _pywrapcp.Solver_SolveAndCommit(self, *args) 509 510 def CheckAssignment(self, solution): 511 r""" Checks whether the given assignment satisfies all relevant constraints.""" 512 return _pywrapcp.Solver_CheckAssignment(self, solution) 513 514 def CheckConstraint(self, ct): 515 r""" 516 Checks whether adding this constraint will lead to an immediate 517 failure. It will return false if the model is already inconsistent, or if 518 adding the constraint makes it inconsistent. 519 """ 520 return _pywrapcp.Solver_CheckConstraint(self, ct) 521 522 def Fail(self): 523 r""" Abandon the current branch in the search tree. A backtrack will follow.""" 524 return _pywrapcp.Solver_Fail(self) 525 526 @staticmethod 527 def MemoryUsage(): 528 r""" Current memory usage in bytes""" 529 return _pywrapcp.Solver_MemoryUsage() 530 531 def WallTime(self): 532 r""" 533 DEPRECATED: Use Now() instead. 534 Time elapsed, in ms since the creation of the solver. 535 """ 536 return _pywrapcp.Solver_WallTime(self) 537 538 def Branches(self): 539 r""" The number of branches explored since the creation of the solver.""" 540 return _pywrapcp.Solver_Branches(self) 541 542 def Solutions(self): 543 r""" The number of solutions found since the start of the search.""" 544 return _pywrapcp.Solver_Solutions(self) 545 546 def Failures(self): 547 r""" The number of failures encountered since the creation of the solver.""" 548 return _pywrapcp.Solver_Failures(self) 549 550 def AcceptedNeighbors(self): 551 r""" The number of accepted neighbors.""" 552 return _pywrapcp.Solver_AcceptedNeighbors(self) 553 554 def Stamp(self): 555 r""" 556 The stamp indicates how many moves in the search tree we have performed. 557 It is useful to detect if we need to update same lazy structures. 558 """ 559 return _pywrapcp.Solver_Stamp(self) 560 561 def FailStamp(self): 562 r""" The fail_stamp() is incremented after each backtrack.""" 563 return _pywrapcp.Solver_FailStamp(self) 564 565 def IntVar(self, *args): 566 r""" 567 *Overload 1:* 568 MakeIntVar will create the best range based int var for the bounds given. 569 570 | 571 572 *Overload 2:* 573 MakeIntVar will create a variable with the given sparse domain. 574 575 | 576 577 *Overload 3:* 578 MakeIntVar will create a variable with the given sparse domain. 579 580 | 581 582 *Overload 4:* 583 MakeIntVar will create the best range based int var for the bounds given. 584 585 | 586 587 *Overload 5:* 588 MakeIntVar will create a variable with the given sparse domain. 589 590 | 591 592 *Overload 6:* 593 MakeIntVar will create a variable with the given sparse domain. 594 """ 595 return _pywrapcp.Solver_IntVar(self, *args) 596 597 def BoolVar(self, *args): 598 r""" 599 *Overload 1:* 600 MakeBoolVar will create a variable with a {0, 1} domain. 601 602 | 603 604 *Overload 2:* 605 MakeBoolVar will create a variable with a {0, 1} domain. 606 """ 607 return _pywrapcp.Solver_BoolVar(self, *args) 608 609 def IntConst(self, *args): 610 r""" 611 *Overload 1:* 612 IntConst will create a constant expression. 613 614 | 615 616 *Overload 2:* 617 IntConst will create a constant expression. 618 """ 619 return _pywrapcp.Solver_IntConst(self, *args) 620 621 def Sum(self, vars): 622 r""" sum of all vars.""" 623 return _pywrapcp.Solver_Sum(self, vars) 624 625 def ScalProd(self, *args): 626 r""" 627 *Overload 1:* 628 scalar product 629 630 | 631 632 *Overload 2:* 633 scalar product 634 """ 635 return _pywrapcp.Solver_ScalProd(self, *args) 636 637 def MonotonicElement(self, values, increasing, index): 638 r""" 639 Function based element. The constraint takes ownership of the 640 callback. The callback must be monotonic. It must be able to 641 cope with any possible value in the domain of 'index' 642 (potentially negative ones too). Furtermore, monotonicity is not 643 checked. Thus giving a non-monotonic function, or specifying an 644 incorrect increasing parameter will result in undefined behavior. 645 """ 646 return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index) 647 648 def Element(self, *args): 649 r""" 650 *Overload 1:* 651 values[index] 652 653 | 654 655 *Overload 2:* 656 values[index] 657 658 | 659 660 *Overload 3:* 661 Function-based element. The constraint takes ownership of the 662 callback. The callback must be able to cope with any possible 663 value in the domain of 'index' (potentially negative ones too). 664 665 | 666 667 *Overload 4:* 668 2D version of function-based element expression, values(expr1, expr2). 669 670 | 671 672 *Overload 5:* 673 vars[expr] 674 """ 675 return _pywrapcp.Solver_Element(self, *args) 676 677 def IndexExpression(self, vars, value): 678 r""" 679 Returns the expression expr such that vars[expr] == value. 680 It assumes that vars are all different. 681 """ 682 return _pywrapcp.Solver_IndexExpression(self, vars, value) 683 684 def Min(self, *args): 685 r""" 686 *Overload 1:* 687 std::min(vars) 688 689 | 690 691 *Overload 2:* 692 std::min (left, right) 693 694 | 695 696 *Overload 3:* 697 std::min(expr, value) 698 699 | 700 701 *Overload 4:* 702 std::min(expr, value) 703 """ 704 return _pywrapcp.Solver_Min(self, *args) 705 706 def Max(self, *args): 707 r""" 708 *Overload 1:* 709 std::max(vars) 710 711 | 712 713 *Overload 2:* 714 std::max(left, right) 715 716 | 717 718 *Overload 3:* 719 std::max(expr, value) 720 721 | 722 723 *Overload 4:* 724 std::max(expr, value) 725 """ 726 return _pywrapcp.Solver_Max(self, *args) 727 728 def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost): 729 r""" Convex piecewise function.""" 730 return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost) 731 732 def SemiContinuousExpr(self, expr, fixed_charge, step): 733 r""" 734 Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) 735 a >= 0 and b >= 0 736 """ 737 return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step) 738 739 def ConditionalExpression(self, condition, expr, unperformed_value): 740 r""" Conditional Expr condition ? expr : unperformed_value""" 741 return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value) 742 743 def TrueConstraint(self): 744 r""" This constraint always succeeds.""" 745 return _pywrapcp.Solver_TrueConstraint(self) 746 747 def FalseConstraint(self, *args): 748 return _pywrapcp.Solver_FalseConstraint(self, *args) 749 750 def IsEqualCstCt(self, var, value, boolvar): 751 r""" boolvar == (var == value)""" 752 return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar) 753 754 def IsEqualCstVar(self, var, value): 755 r""" status var of (var == value)""" 756 return _pywrapcp.Solver_IsEqualCstVar(self, var, value) 757 758 def IsEqualCt(self, v1, v2, b): 759 r""" b == (v1 == v2)""" 760 return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b) 761 762 def IsEqualVar(self, v1, v2): 763 r""" status var of (v1 == v2)""" 764 return _pywrapcp.Solver_IsEqualVar(self, v1, v2) 765 766 def IsDifferentCstCt(self, var, value, boolvar): 767 r""" boolvar == (var != value)""" 768 return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar) 769 770 def IsDifferentCstVar(self, var, value): 771 r""" status var of (var != value)""" 772 return _pywrapcp.Solver_IsDifferentCstVar(self, var, value) 773 774 def IsDifferentVar(self, v1, v2): 775 r""" status var of (v1 != v2)""" 776 return _pywrapcp.Solver_IsDifferentVar(self, v1, v2) 777 778 def IsDifferentCt(self, v1, v2, b): 779 r""" b == (v1 != v2)""" 780 return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b) 781 782 def IsLessOrEqualCstCt(self, var, value, boolvar): 783 r""" boolvar == (var <= value)""" 784 return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar) 785 786 def IsLessOrEqualCstVar(self, var, value): 787 r""" status var of (var <= value)""" 788 return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value) 789 790 def IsLessOrEqualVar(self, left, right): 791 r""" status var of (left <= right)""" 792 return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right) 793 794 def IsLessOrEqualCt(self, left, right, b): 795 r""" b == (left <= right)""" 796 return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b) 797 798 def IsGreaterOrEqualCstCt(self, var, value, boolvar): 799 r""" boolvar == (var >= value)""" 800 return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar) 801 802 def IsGreaterOrEqualCstVar(self, var, value): 803 r""" status var of (var >= value)""" 804 return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value) 805 806 def IsGreaterOrEqualVar(self, left, right): 807 r""" status var of (left >= right)""" 808 return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right) 809 810 def IsGreaterOrEqualCt(self, left, right, b): 811 r""" b == (left >= right)""" 812 return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b) 813 814 def IsGreaterCstCt(self, v, c, b): 815 r""" b == (v > c)""" 816 return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b) 817 818 def IsGreaterCstVar(self, var, value): 819 r""" status var of (var > value)""" 820 return _pywrapcp.Solver_IsGreaterCstVar(self, var, value) 821 822 def IsGreaterVar(self, left, right): 823 r""" status var of (left > right)""" 824 return _pywrapcp.Solver_IsGreaterVar(self, left, right) 825 826 def IsGreaterCt(self, left, right, b): 827 r""" b == (left > right)""" 828 return _pywrapcp.Solver_IsGreaterCt(self, left, right, b) 829 830 def IsLessCstCt(self, v, c, b): 831 r""" b == (v < c)""" 832 return _pywrapcp.Solver_IsLessCstCt(self, v, c, b) 833 834 def IsLessCstVar(self, var, value): 835 r""" status var of (var < value)""" 836 return _pywrapcp.Solver_IsLessCstVar(self, var, value) 837 838 def IsLessVar(self, left, right): 839 r""" status var of (left < right)""" 840 return _pywrapcp.Solver_IsLessVar(self, left, right) 841 842 def IsLessCt(self, left, right, b): 843 r""" b == (left < right)""" 844 return _pywrapcp.Solver_IsLessCt(self, left, right, b) 845 846 def SumLessOrEqual(self, vars, cst): 847 r""" Variation on arrays.""" 848 return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst) 849 850 def SumGreaterOrEqual(self, vars, cst): 851 return _pywrapcp.Solver_SumGreaterOrEqual(self, vars, cst) 852 853 def SumEquality(self, *args): 854 return _pywrapcp.Solver_SumEquality(self, *args) 855 856 def ScalProdEquality(self, *args): 857 return _pywrapcp.Solver_ScalProdEquality(self, *args) 858 859 def ScalProdGreaterOrEqual(self, *args): 860 return _pywrapcp.Solver_ScalProdGreaterOrEqual(self, *args) 861 862 def ScalProdLessOrEqual(self, *args): 863 return _pywrapcp.Solver_ScalProdLessOrEqual(self, *args) 864 865 def MinEquality(self, vars, min_var): 866 return _pywrapcp.Solver_MinEquality(self, vars, min_var) 867 868 def MaxEquality(self, vars, max_var): 869 return _pywrapcp.Solver_MaxEquality(self, vars, max_var) 870 871 def ElementEquality(self, *args): 872 return _pywrapcp.Solver_ElementEquality(self, *args) 873 874 def AbsEquality(self, var, abs_var): 875 r""" Creates the constraint abs(var) == abs_var.""" 876 return _pywrapcp.Solver_AbsEquality(self, var, abs_var) 877 878 def IndexOfConstraint(self, vars, index, target): 879 r""" 880 This constraint is a special case of the element constraint with 881 an array of integer variables, where the variables are all 882 different and the index variable is constrained such that 883 vars[index] == target. 884 """ 885 return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target) 886 887 def ConstraintInitialPropagateCallback(self, ct): 888 r""" 889 This method is a specialized case of the MakeConstraintDemon 890 method to call the InitiatePropagate of the constraint 'ct'. 891 """ 892 return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct) 893 894 def DelayedConstraintInitialPropagateCallback(self, ct): 895 r""" 896 This method is a specialized case of the MakeConstraintDemon 897 method to call the InitiatePropagate of the constraint 'ct' with 898 low priority. 899 """ 900 return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct) 901 902 def ClosureDemon(self, closure): 903 r""" Creates a demon from a closure.""" 904 return _pywrapcp.Solver_ClosureDemon(self, closure) 905 906 def BetweenCt(self, expr, l, u): 907 r""" (l <= expr <= u)""" 908 return _pywrapcp.Solver_BetweenCt(self, expr, l, u) 909 910 def IsBetweenCt(self, expr, l, u, b): 911 r""" b == (l <= expr <= u)""" 912 return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b) 913 914 def IsBetweenVar(self, v, l, u): 915 return _pywrapcp.Solver_IsBetweenVar(self, v, l, u) 916 917 def MemberCt(self, *args): 918 return _pywrapcp.Solver_MemberCt(self, *args) 919 920 def NotMemberCt(self, *args): 921 r""" 922 *Overload 1:* 923 expr not in set. 924 925 | 926 927 *Overload 2:* 928 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 929 930 | 931 932 *Overload 3:* 933 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 934 """ 935 return _pywrapcp.Solver_NotMemberCt(self, *args) 936 937 def IsMemberCt(self, *args): 938 return _pywrapcp.Solver_IsMemberCt(self, *args) 939 940 def IsMemberVar(self, *args): 941 return _pywrapcp.Solver_IsMemberVar(self, *args) 942 943 def Count(self, *args): 944 r""" 945 *Overload 1:* 946 |{i | vars[i] == value}| == max_count 947 948 | 949 950 *Overload 2:* 951 |{i | vars[i] == value}| == max_count 952 """ 953 return _pywrapcp.Solver_Count(self, *args) 954 955 def Distribute(self, *args): 956 r""" 957 *Overload 1:* 958 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 959 960 | 961 962 *Overload 2:* 963 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 964 965 | 966 967 *Overload 3:* 968 Aggregated version of count: |{i | v[i] == j}| == cards[j] 969 970 | 971 972 *Overload 4:* 973 Aggregated version of count with bounded cardinalities: 974 forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max 975 976 | 977 978 *Overload 5:* 979 Aggregated version of count with bounded cardinalities: 980 forall j in 0 .. card_size - 1: 981 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 982 983 | 984 985 *Overload 6:* 986 Aggregated version of count with bounded cardinalities: 987 forall j in 0 .. card_size - 1: 988 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 989 990 | 991 992 *Overload 7:* 993 Aggregated version of count with bounded cardinalities: 994 forall j in 0 .. card_size - 1: 995 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 996 997 | 998 999 *Overload 8:* 1000 Aggregated version of count with bounded cardinalities: 1001 forall j in 0 .. card_size - 1: 1002 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 1003 """ 1004 return _pywrapcp.Solver_Distribute(self, *args) 1005 1006 def Deviation(self, vars, deviation_var, total_sum): 1007 r""" 1008 Deviation constraint: 1009 sum_i |n * vars[i] - total_sum| <= deviation_var and 1010 sum_i vars[i] == total_sum 1011 n = #vars 1012 """ 1013 return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum) 1014 1015 def AllDifferent(self, *args): 1016 r""" 1017 *Overload 1:* 1018 All variables are pairwise different. This corresponds to the 1019 stronger version of the propagation algorithm. 1020 1021 | 1022 1023 *Overload 2:* 1024 All variables are pairwise different. If 'stronger_propagation' 1025 is true, stronger, and potentially slower propagation will 1026 occur. This API will be deprecated in the future. 1027 """ 1028 return _pywrapcp.Solver_AllDifferent(self, *args) 1029 1030 def AllDifferentExcept(self, vars, escape_value): 1031 r""" 1032 All variables are pairwise different, unless they are assigned to 1033 the escape value. 1034 """ 1035 return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value) 1036 1037 def SortingConstraint(self, vars, sorted): 1038 r""" 1039 Creates a constraint binding the arrays of variables "vars" and 1040 "sorted_vars": sorted_vars[0] must be equal to the minimum of all 1041 variables in vars, and so on: the value of sorted_vars[i] must be 1042 equal to the i-th value of variables invars. 1043 1044 This constraint propagates in both directions: from "vars" to 1045 "sorted_vars" and vice-versa. 1046 1047 Behind the scenes, this constraint maintains that: 1048 - sorted is always increasing. 1049 - whatever the values of vars, there exists a permutation that 1050 injects its values into the sorted variables. 1051 1052 For more info, please have a look at: 1053 https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf 1054 """ 1055 return _pywrapcp.Solver_SortingConstraint(self, vars, sorted) 1056 1057 def LexicalLess(self, left, right): 1058 r""" 1059 Creates a constraint that enforces that left is lexicographically less 1060 than right. 1061 """ 1062 return _pywrapcp.Solver_LexicalLess(self, left, right) 1063 1064 def LexicalLessOrEqual(self, left, right): 1065 r""" 1066 Creates a constraint that enforces that left is lexicographically less 1067 than or equal to right. 1068 """ 1069 return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right) 1070 1071 def InversePermutationConstraint(self, left, right): 1072 r""" 1073 Creates a constraint that enforces that 'left' and 'right' both 1074 represent permutations of [0..left.size()-1], and that 'right' is 1075 the inverse permutation of 'left', i.e. for all i in 1076 [0..left.size()-1], right[left[i]] = i. 1077 """ 1078 return _pywrapcp.Solver_InversePermutationConstraint(self, left, right) 1079 1080 def NullIntersect(self, first_vars, second_vars): 1081 r""" 1082 Creates a constraint that states that all variables in the first 1083 vector are different from all variables in the second 1084 group. Thus the set of values in the first vector does not 1085 intersect with the set of values in the second vector. 1086 """ 1087 return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars) 1088 1089 def NullIntersectExcept(self, first_vars, second_vars, escape_value): 1090 r""" 1091 Creates a constraint that states that all variables in the first 1092 vector are different from all variables from the second group, 1093 unless they are assigned to the escape value. Thus the set of 1094 values in the first vector minus the escape value does not 1095 intersect with the set of values in the second vector. 1096 """ 1097 return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value) 1098 1099 def Circuit(self, nexts): 1100 r""" Force the "nexts" variable to create a complete Hamiltonian path.""" 1101 return _pywrapcp.Solver_Circuit(self, nexts) 1102 1103 def SubCircuit(self, nexts): 1104 r""" 1105 Force the "nexts" variable to create a complete Hamiltonian path 1106 for those that do not loop upon themselves. 1107 """ 1108 return _pywrapcp.Solver_SubCircuit(self, nexts) 1109 1110 def DelayedPathCumul(self, nexts, active, cumuls, transits): 1111 r""" 1112 Delayed version of the same constraint: propagation on the nexts variables 1113 is delayed until all constraints have propagated. 1114 """ 1115 return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits) 1116 1117 def PathCumul(self, *args): 1118 r""" 1119 *Overload 1:* 1120 Creates a constraint which accumulates values along a path such that: 1121 cumuls[next[i]] = cumuls[i] + transits[i]. 1122 Active variables indicate if the corresponding next variable is active; 1123 this could be useful to model unperformed nodes in a routing problem. 1124 1125 | 1126 1127 *Overload 2:* 1128 Creates a constraint which accumulates values along a path such that: 1129 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). 1130 Active variables indicate if the corresponding next variable is active; 1131 this could be useful to model unperformed nodes in a routing problem. 1132 Ownership of transit_evaluator is taken and it must be a repeatable 1133 callback. 1134 1135 | 1136 1137 *Overload 3:* 1138 Creates a constraint which accumulates values along a path such that: 1139 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. 1140 Active variables indicate if the corresponding next variable is active; 1141 this could be useful to model unperformed nodes in a routing problem. 1142 Ownership of transit_evaluator is taken and it must be a repeatable 1143 callback. 1144 """ 1145 return _pywrapcp.Solver_PathCumul(self, *args) 1146 1147 def AllowedAssignments(self, *args): 1148 r""" 1149 *Overload 1:* 1150 This method creates a constraint where the graph of the relation 1151 between the variables is given in extension. There are 'arity' 1152 variables involved in the relation and the graph is given by a 1153 integer tuple set. 1154 1155 | 1156 1157 *Overload 2:* 1158 Compatibility layer for Python API. 1159 """ 1160 return _pywrapcp.Solver_AllowedAssignments(self, *args) 1161 1162 def TransitionConstraint(self, *args): 1163 return _pywrapcp.Solver_TransitionConstraint(self, *args) 1164 1165 def NonOverlappingBoxesConstraint(self, *args): 1166 return _pywrapcp.Solver_NonOverlappingBoxesConstraint(self, *args) 1167 1168 def Pack(self, vars, number_of_bins): 1169 r""" 1170 This constraint packs all variables onto 'number_of_bins' 1171 variables. For any given variable, a value of 'number_of_bins' 1172 indicates that the variable is not assigned to any bin. 1173 Dimensions, i.e., cumulative constraints on this packing, can be 1174 added directly from the pack class. 1175 """ 1176 return _pywrapcp.Solver_Pack(self, vars, number_of_bins) 1177 1178 def FixedDurationIntervalVar(self, *args): 1179 r""" 1180 *Overload 1:* 1181 Creates an interval var with a fixed duration. The duration must 1182 be greater than 0. If optional is true, then the interval can be 1183 performed or unperformed. If optional is false, then the interval 1184 is always performed. 1185 1186 | 1187 1188 *Overload 2:* 1189 Creates a performed interval var with a fixed duration. The duration must 1190 be greater than 0. 1191 1192 | 1193 1194 *Overload 3:* 1195 Creates an interval var with a fixed duration, and performed_variable. 1196 The duration must be greater than 0. 1197 """ 1198 return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args) 1199 1200 def FixedInterval(self, start, duration, name): 1201 r""" Creates a fixed and performed interval.""" 1202 return _pywrapcp.Solver_FixedInterval(self, start, duration, name) 1203 1204 def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name): 1205 r""" 1206 Creates an interval var by specifying the bounds on start, 1207 duration, and end. 1208 """ 1209 return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name) 1210 1211 def MirrorInterval(self, interval_var): 1212 r""" 1213 Creates an interval var that is the mirror image of the given one, that 1214 is, the interval var obtained by reversing the axis. 1215 """ 1216 return _pywrapcp.Solver_MirrorInterval(self, interval_var) 1217 1218 def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1219 r""" 1220 Creates an interval var with a fixed duration whose start is 1221 synchronized with the start of another interval, with a given 1222 offset. The performed status is also in sync with the performed 1223 status of the given interval variable. 1224 """ 1225 return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1226 1227 def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1228 r""" 1229 Creates an interval var with a fixed duration whose start is 1230 synchronized with the end of another interval, with a given 1231 offset. The performed status is also in sync with the performed 1232 status of the given interval variable. 1233 """ 1234 return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1235 1236 def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1237 r""" 1238 Creates an interval var with a fixed duration whose end is 1239 synchronized with the start of another interval, with a given 1240 offset. The performed status is also in sync with the performed 1241 status of the given interval variable. 1242 """ 1243 return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset) 1244 1245 def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1246 r""" 1247 Creates an interval var with a fixed duration whose end is 1248 synchronized with the end of another interval, with a given 1249 offset. The performed status is also in sync with the performed 1250 status of the given interval variable. 1251 """ 1252 return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset) 1253 1254 def IntervalRelaxedMin(self, interval_var): 1255 r""" 1256 Creates and returns an interval variable that wraps around the given one, 1257 relaxing the min start and end. Relaxing means making unbounded when 1258 optional. If the variable is non-optional, this method returns 1259 interval_var. 1260 1261 More precisely, such an interval variable behaves as follows: 1262 When the underlying must be performed, the returned interval variable 1263 behaves exactly as the underlying; 1264 When the underlying may or may not be performed, the returned interval 1265 variable behaves like the underlying, except that it is unbounded on 1266 the min side; 1267 When the underlying cannot be performed, the returned interval variable 1268 is of duration 0 and must be performed in an interval unbounded on 1269 both sides. 1270 1271 This is very useful to implement propagators that may only modify 1272 the start max or end max. 1273 """ 1274 return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var) 1275 1276 def IntervalRelaxedMax(self, interval_var): 1277 r""" 1278 Creates and returns an interval variable that wraps around the given one, 1279 relaxing the max start and end. Relaxing means making unbounded when 1280 optional. If the variable is non optional, this method returns 1281 interval_var. 1282 1283 More precisely, such an interval variable behaves as follows: 1284 When the underlying must be performed, the returned interval variable 1285 behaves exactly as the underlying; 1286 When the underlying may or may not be performed, the returned interval 1287 variable behaves like the underlying, except that it is unbounded on 1288 the max side; 1289 When the underlying cannot be performed, the returned interval variable 1290 is of duration 0 and must be performed in an interval unbounded on 1291 both sides. 1292 1293 This is very useful for implementing propagators that may only modify 1294 the start min or end min. 1295 """ 1296 return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var) 1297 1298 def TemporalDisjunction(self, *args): 1299 r""" 1300 *Overload 1:* 1301 This constraint implements a temporal disjunction between two 1302 interval vars t1 and t2. 'alt' indicates which alternative was 1303 chosen (alt == 0 is equivalent to t1 before t2). 1304 1305 | 1306 1307 *Overload 2:* 1308 This constraint implements a temporal disjunction between two 1309 interval vars. 1310 """ 1311 return _pywrapcp.Solver_TemporalDisjunction(self, *args) 1312 1313 def DisjunctiveConstraint(self, intervals, name): 1314 r""" 1315 This constraint forces all interval vars into an non-overlapping 1316 sequence. Intervals with zero duration can be scheduled anywhere. 1317 """ 1318 return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name) 1319 1320 def Cumulative(self, *args): 1321 r""" 1322 *Overload 1:* 1323 This constraint forces that, for any integer t, the sum of the demands 1324 corresponding to an interval containing t does not exceed the given 1325 capacity. 1326 1327 Intervals and demands should be vectors of equal size. 1328 1329 Demands should only contain non-negative values. Zero values are 1330 supported, and the corresponding intervals are filtered out, as they 1331 neither impact nor are impacted by this constraint. 1332 1333 | 1334 1335 *Overload 2:* 1336 This constraint forces that, for any integer t, the sum of the demands 1337 corresponding to an interval containing t does not exceed the given 1338 capacity. 1339 1340 Intervals and demands should be vectors of equal size. 1341 1342 Demands should only contain non-negative values. Zero values are 1343 supported, and the corresponding intervals are filtered out, as they 1344 neither impact nor are impacted by this constraint. 1345 1346 | 1347 1348 *Overload 3:* 1349 This constraint forces that, for any integer t, the sum of the demands 1350 corresponding to an interval containing t does not exceed the given 1351 capacity. 1352 1353 Intervals and demands should be vectors of equal size. 1354 1355 Demands should only contain non-negative values. Zero values are 1356 supported, and the corresponding intervals are filtered out, as they 1357 neither impact nor are impacted by this constraint. 1358 1359 | 1360 1361 *Overload 4:* 1362 This constraint enforces that, for any integer t, the sum of the demands 1363 corresponding to an interval containing t does not exceed the given 1364 capacity. 1365 1366 Intervals and demands should be vectors of equal size. 1367 1368 Demands should only contain non-negative values. Zero values are 1369 supported, and the corresponding intervals are filtered out, as they 1370 neither impact nor are impacted by this constraint. 1371 1372 | 1373 1374 *Overload 5:* 1375 This constraint enforces that, for any integer t, the sum of demands 1376 corresponding to an interval containing t does not exceed the given 1377 capacity. 1378 1379 Intervals and demands should be vectors of equal size. 1380 1381 Demands should be positive. 1382 1383 | 1384 1385 *Overload 6:* 1386 This constraint enforces that, for any integer t, the sum of demands 1387 corresponding to an interval containing t does not exceed the given 1388 capacity. 1389 1390 Intervals and demands should be vectors of equal size. 1391 1392 Demands should be positive. 1393 """ 1394 return _pywrapcp.Solver_Cumulative(self, *args) 1395 1396 def Cover(self, vars, target_var): 1397 r""" 1398 This constraint states that the target_var is the convex hull of 1399 the intervals. If none of the interval variables is performed, 1400 then the target var is unperformed too. Also, if the target 1401 variable is unperformed, then all the intervals variables are 1402 unperformed too. 1403 """ 1404 return _pywrapcp.Solver_Cover(self, vars, target_var) 1405 1406 def Assignment(self, *args): 1407 r""" 1408 *Overload 1:* 1409 This method creates an empty assignment. 1410 1411 | 1412 1413 *Overload 2:* 1414 This method creates an assignment which is a copy of 'a'. 1415 """ 1416 return _pywrapcp.Solver_Assignment(self, *args) 1417 1418 def FirstSolutionCollector(self, *args): 1419 r""" 1420 *Overload 1:* 1421 Collect the first solution of the search. 1422 1423 | 1424 1425 *Overload 2:* 1426 Collect the first solution of the search. The variables will need to 1427 be added later. 1428 """ 1429 return _pywrapcp.Solver_FirstSolutionCollector(self, *args) 1430 1431 def LastSolutionCollector(self, *args): 1432 r""" 1433 *Overload 1:* 1434 Collect the last solution of the search. 1435 1436 | 1437 1438 *Overload 2:* 1439 Collect the last solution of the search. The variables will need to 1440 be added later. 1441 """ 1442 return _pywrapcp.Solver_LastSolutionCollector(self, *args) 1443 1444 def BestValueSolutionCollector(self, *args): 1445 r""" 1446 *Overload 1:* 1447 Collect the solution corresponding to the optimal value of the objective 1448 of 'assignment'; if 'assignment' does not have an objective no solution is 1449 collected. This collector only collects one solution corresponding to the 1450 best objective value (the first one found). 1451 1452 | 1453 1454 *Overload 2:* 1455 Collect the solution corresponding to the optimal value of the 1456 objective of the internal assignment; if this assignment does not have an 1457 objective no solution is collected. This collector only collects one 1458 solution corresponding to the best objective value (the first one found). 1459 The variables and objective(s) will need to be added later. 1460 """ 1461 return _pywrapcp.Solver_BestValueSolutionCollector(self, *args) 1462 1463 def AllSolutionCollector(self, *args): 1464 r""" 1465 *Overload 1:* 1466 Collect all solutions of the search. 1467 1468 | 1469 1470 *Overload 2:* 1471 Collect all solutions of the search. The variables will need to 1472 be added later. 1473 """ 1474 return _pywrapcp.Solver_AllSolutionCollector(self, *args) 1475 1476 def Minimize(self, v, step): 1477 r""" Creates a minimization objective.""" 1478 return _pywrapcp.Solver_Minimize(self, v, step) 1479 1480 def Maximize(self, v, step): 1481 r""" Creates a maximization objective.""" 1482 return _pywrapcp.Solver_Maximize(self, v, step) 1483 1484 def Optimize(self, maximize, v, step): 1485 r""" Creates a objective with a given sense (true = maximization).""" 1486 return _pywrapcp.Solver_Optimize(self, maximize, v, step) 1487 1488 def WeightedMinimize(self, *args): 1489 r""" 1490 *Overload 1:* 1491 Creates a minimization weighted objective. The actual objective is 1492 scalar_prod(sub_objectives, weights). 1493 1494 | 1495 1496 *Overload 2:* 1497 Creates a minimization weighted objective. The actual objective is 1498 scalar_prod(sub_objectives, weights). 1499 """ 1500 return _pywrapcp.Solver_WeightedMinimize(self, *args) 1501 1502 def WeightedMaximize(self, *args): 1503 r""" 1504 *Overload 1:* 1505 Creates a maximization weigthed objective. 1506 1507 | 1508 1509 *Overload 2:* 1510 Creates a maximization weigthed objective. 1511 """ 1512 return _pywrapcp.Solver_WeightedMaximize(self, *args) 1513 1514 def WeightedOptimize(self, *args): 1515 r""" 1516 *Overload 1:* 1517 Creates a weighted objective with a given sense (true = maximization). 1518 1519 | 1520 1521 *Overload 2:* 1522 Creates a weighted objective with a given sense (true = maximization). 1523 """ 1524 return _pywrapcp.Solver_WeightedOptimize(self, *args) 1525 1526 def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor): 1527 r""" 1528 MetaHeuristics which try to get the search out of local optima. 1529 Creates a Tabu Search monitor. 1530 In the context of local search the behavior is similar to MakeOptimize(), 1531 creating an objective in a given sense. The behavior differs once a local 1532 optimum is reached: thereafter solutions which degrade the value of the 1533 objective are allowed if they are not "tabu". A solution is "tabu" if it 1534 doesn't respect the following rules: 1535 - improving the best solution found so far 1536 - variables in the "keep" list must keep their value, variables in the 1537 "forbid" list must not take the value they have in the list. 1538 Variables with new values enter the tabu lists after each new solution 1539 found and leave the lists after a given number of iterations (called 1540 tenure). Only the variables passed to the method can enter the lists. 1541 The tabu criterion is softened by the tabu factor which gives the number 1542 of "tabu" violations which is tolerated; a factor of 1 means no violations 1543 allowed; a factor of 0 means all violations are allowed. 1544 """ 1545 return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor) 1546 1547 def SimulatedAnnealing(self, maximize, v, step, initial_temperature): 1548 r""" Creates a Simulated Annealing monitor.""" 1549 return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature) 1550 1551 def LubyRestart(self, scale_factor): 1552 r""" 1553 This search monitor will restart the search periodically. 1554 At the iteration n, it will restart after scale_factor * Luby(n) failures 1555 where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...). 1556 """ 1557 return _pywrapcp.Solver_LubyRestart(self, scale_factor) 1558 1559 def ConstantRestart(self, frequency): 1560 r""" 1561 This search monitor will restart the search periodically after 'frequency' 1562 failures. 1563 """ 1564 return _pywrapcp.Solver_ConstantRestart(self, frequency) 1565 1566 def TimeLimit(self, *args): 1567 return _pywrapcp.Solver_TimeLimit(self, *args) 1568 1569 def BranchesLimit(self, branches): 1570 r""" 1571 Creates a search limit that constrains the number of branches 1572 explored in the search tree. 1573 """ 1574 return _pywrapcp.Solver_BranchesLimit(self, branches) 1575 1576 def FailuresLimit(self, failures): 1577 r""" 1578 Creates a search limit that constrains the number of failures 1579 that can happen when exploring the search tree. 1580 """ 1581 return _pywrapcp.Solver_FailuresLimit(self, failures) 1582 1583 def SolutionsLimit(self, solutions): 1584 r""" 1585 Creates a search limit that constrains the number of solutions found 1586 during the search. 1587 """ 1588 return _pywrapcp.Solver_SolutionsLimit(self, solutions) 1589 1590 def Limit(self, *args): 1591 r""" 1592 *Overload 1:* 1593 Limits the search with the 'time', 'branches', 'failures' and 1594 'solutions' limits. 'smart_time_check' reduces the calls to the wall 1595 1596 | 1597 1598 *Overload 2:* 1599 Creates a search limit from its protobuf description 1600 1601 | 1602 1603 *Overload 3:* 1604 Creates a search limit that is reached when either of the underlying limit 1605 is reached. That is, the returned limit is more stringent than both 1606 argument limits. 1607 """ 1608 return _pywrapcp.Solver_Limit(self, *args) 1609 1610 def CustomLimit(self, limiter): 1611 r""" 1612 Callback-based search limit. Search stops when limiter returns true; if 1613 this happens at a leaf the corresponding solution will be rejected. 1614 """ 1615 return _pywrapcp.Solver_CustomLimit(self, limiter) 1616 1617 def SearchLog(self, *args): 1618 return _pywrapcp.Solver_SearchLog(self, *args) 1619 1620 def SearchTrace(self, prefix): 1621 r""" 1622 Creates a search monitor that will trace precisely the behavior of the 1623 search. Use this only for low level debugging. 1624 """ 1625 return _pywrapcp.Solver_SearchTrace(self, prefix) 1626 1627 def PrintModelVisitor(self): 1628 r""" Prints the model.""" 1629 return _pywrapcp.Solver_PrintModelVisitor(self) 1630 1631 def StatisticsModelVisitor(self): 1632 r""" Displays some nice statistics on the model.""" 1633 return _pywrapcp.Solver_StatisticsModelVisitor(self) 1634 1635 def AssignVariableValue(self, var, val): 1636 r""" Decisions.""" 1637 return _pywrapcp.Solver_AssignVariableValue(self, var, val) 1638 1639 def VariableLessOrEqualValue(self, var, value): 1640 return _pywrapcp.Solver_VariableLessOrEqualValue(self, var, value) 1641 1642 def VariableGreaterOrEqualValue(self, var, value): 1643 return _pywrapcp.Solver_VariableGreaterOrEqualValue(self, var, value) 1644 1645 def SplitVariableDomain(self, var, val, start_with_lower_half): 1646 return _pywrapcp.Solver_SplitVariableDomain(self, var, val, start_with_lower_half) 1647 1648 def AssignVariableValueOrFail(self, var, value): 1649 return _pywrapcp.Solver_AssignVariableValueOrFail(self, var, value) 1650 1651 def AssignVariablesValues(self, vars, values): 1652 return _pywrapcp.Solver_AssignVariablesValues(self, vars, values) 1653 1654 def FailDecision(self): 1655 return _pywrapcp.Solver_FailDecision(self) 1656 1657 def Decision(self, apply, refute): 1658 return _pywrapcp.Solver_Decision(self, apply, refute) 1659 1660 def Compose(self, dbs): 1661 return _pywrapcp.Solver_Compose(self, dbs) 1662 1663 def Try(self, dbs): 1664 return _pywrapcp.Solver_Try(self, dbs) 1665 1666 def DefaultPhase(self, *args): 1667 return _pywrapcp.Solver_DefaultPhase(self, *args) 1668 1669 def ScheduleOrPostpone(self, var, est, marker): 1670 r""" 1671 Returns a decision that tries to schedule a task at a given time. 1672 On the Apply branch, it will set that interval var as performed and set 1673 its start to 'est'. On the Refute branch, it will just update the 1674 'marker' to 'est' + 1. This decision is used in the 1675 INTERVAL_SET_TIMES_FORWARD strategy. 1676 """ 1677 return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker) 1678 1679 def ScheduleOrExpedite(self, var, est, marker): 1680 r""" 1681 Returns a decision that tries to schedule a task at a given time. 1682 On the Apply branch, it will set that interval var as performed and set 1683 its end to 'est'. On the Refute branch, it will just update the 1684 'marker' to 'est' - 1. This decision is used in the 1685 INTERVAL_SET_TIMES_BACKWARD strategy. 1686 """ 1687 return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker) 1688 1689 def RankFirstInterval(self, sequence, index): 1690 r""" 1691 Returns a decision that tries to rank first the ith interval var 1692 in the sequence variable. 1693 """ 1694 return _pywrapcp.Solver_RankFirstInterval(self, sequence, index) 1695 1696 def RankLastInterval(self, sequence, index): 1697 r""" 1698 Returns a decision that tries to rank last the ith interval var 1699 in the sequence variable. 1700 """ 1701 return _pywrapcp.Solver_RankLastInterval(self, sequence, index) 1702 1703 def Phase(self, *args): 1704 return _pywrapcp.Solver_Phase(self, *args) 1705 1706 def DecisionBuilderFromAssignment(self, assignment, db, vars): 1707 r""" 1708 Returns a decision builder for which the left-most leaf corresponds 1709 to assignment, the rest of the tree being explored using 'db'. 1710 """ 1711 return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars) 1712 1713 def ConstraintAdder(self, ct): 1714 r""" 1715 Returns a decision builder that will add the given constraint to 1716 the model. 1717 """ 1718 return _pywrapcp.Solver_ConstraintAdder(self, ct) 1719 1720 def SolveOnce(self, db, monitors): 1721 return _pywrapcp.Solver_SolveOnce(self, db, monitors) 1722 1723 def NestedOptimize(self, *args): 1724 return _pywrapcp.Solver_NestedOptimize(self, *args) 1725 1726 def RestoreAssignment(self, assignment): 1727 r""" 1728 Returns a DecisionBuilder which restores an Assignment 1729 (calls void Assignment::Restore()) 1730 """ 1731 return _pywrapcp.Solver_RestoreAssignment(self, assignment) 1732 1733 def StoreAssignment(self, assignment): 1734 r""" 1735 Returns a DecisionBuilder which stores an Assignment 1736 (calls void Assignment::Store()) 1737 """ 1738 return _pywrapcp.Solver_StoreAssignment(self, assignment) 1739 1740 def Operator(self, *args): 1741 return _pywrapcp.Solver_Operator(self, *args) 1742 1743 def RandomLnsOperator(self, *args): 1744 return _pywrapcp.Solver_RandomLnsOperator(self, *args) 1745 1746 def MoveTowardTargetOperator(self, *args): 1747 r""" 1748 *Overload 1:* 1749 Creates a local search operator that tries to move the assignment of some 1750 variables toward a target. The target is given as an Assignment. This 1751 operator generates neighbors in which the only difference compared to the 1752 current state is that one variable that belongs to the target assignment 1753 is set to its target value. 1754 1755 | 1756 1757 *Overload 2:* 1758 Creates a local search operator that tries to move the assignment of some 1759 variables toward a target. The target is given either as two vectors: a 1760 vector of variables and a vector of associated target values. The two 1761 vectors should be of the same length. This operator generates neighbors in 1762 which the only difference compared to the current state is that one 1763 variable that belongs to the given vector is set to its target value. 1764 """ 1765 return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args) 1766 1767 def ConcatenateOperators(self, *args): 1768 return _pywrapcp.Solver_ConcatenateOperators(self, *args) 1769 1770 def RandomConcatenateOperators(self, *args): 1771 r""" 1772 *Overload 1:* 1773 Randomized version of local search concatenator; calls a random operator 1774 at each call to MakeNextNeighbor(). 1775 1776 | 1777 1778 *Overload 2:* 1779 Randomized version of local search concatenator; calls a random operator 1780 at each call to MakeNextNeighbor(). The provided seed is used to 1781 initialize the random number generator. 1782 """ 1783 return _pywrapcp.Solver_RandomConcatenateOperators(self, *args) 1784 1785 def NeighborhoodLimit(self, op, limit): 1786 r""" 1787 Creates a local search operator that wraps another local search 1788 operator and limits the number of neighbors explored (i.e., calls 1789 to MakeNextNeighbor from the current solution (between two calls 1790 to Start()). When this limit is reached, MakeNextNeighbor() 1791 returns false. The counter is cleared when Start() is called. 1792 """ 1793 return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit) 1794 1795 def LocalSearchPhase(self, *args): 1796 return _pywrapcp.Solver_LocalSearchPhase(self, *args) 1797 1798 def LocalSearchPhaseParameters(self, *args): 1799 return _pywrapcp.Solver_LocalSearchPhaseParameters(self, *args) 1800 1801 def TopProgressPercent(self): 1802 r""" 1803 Returns a percentage representing the propress of the search before 1804 reaching the limits of the top-level search (can be called from a nested 1805 solve). 1806 """ 1807 return _pywrapcp.Solver_TopProgressPercent(self) 1808 1809 def SearchDepth(self): 1810 r""" 1811 Gets the search depth of the current active search. Returns -1 if 1812 there is no active search opened. 1813 """ 1814 return _pywrapcp.Solver_SearchDepth(self) 1815 1816 def SearchLeftDepth(self): 1817 r""" 1818 Gets the search left depth of the current active search. Returns -1 if 1819 there is no active search opened. 1820 """ 1821 return _pywrapcp.Solver_SearchLeftDepth(self) 1822 1823 def SolveDepth(self): 1824 r""" 1825 Gets the number of nested searches. It returns 0 outside search, 1826 1 during the top level search, 2 or more in case of nested searches. 1827 """ 1828 return _pywrapcp.Solver_SolveDepth(self) 1829 1830 def Rand64(self, size): 1831 r""" Returns a random value between 0 and 'size' - 1;""" 1832 return _pywrapcp.Solver_Rand64(self, size) 1833 1834 def Rand32(self, size): 1835 r""" Returns a random value between 0 and 'size' - 1;""" 1836 return _pywrapcp.Solver_Rand32(self, size) 1837 1838 def ReSeed(self, seed): 1839 r""" Reseed the solver random generator.""" 1840 return _pywrapcp.Solver_ReSeed(self, seed) 1841 1842 def LocalSearchProfile(self): 1843 r""" Returns local search profiling information in a human readable format.""" 1844 return _pywrapcp.Solver_LocalSearchProfile(self) 1845 1846 def Constraints(self): 1847 r""" 1848 Counts the number of constraints that have been added 1849 to the solver before the search. 1850 """ 1851 return _pywrapcp.Solver_Constraints(self) 1852 1853 def Accept(self, visitor): 1854 r""" Accepts the given model visitor.""" 1855 return _pywrapcp.Solver_Accept(self, visitor) 1856 1857 def FinishCurrentSearch(self): 1858 r""" Tells the solver to kill or restart the current search.""" 1859 return _pywrapcp.Solver_FinishCurrentSearch(self) 1860 1861 def RestartCurrentSearch(self): 1862 return _pywrapcp.Solver_RestartCurrentSearch(self) 1863 1864 def ShouldFail(self): 1865 r""" 1866 These methods are only useful for the SWIG wrappers, which need a way 1867 to externally cause the Solver to fail. 1868 """ 1869 return _pywrapcp.Solver_ShouldFail(self) 1870 1871 def __str__(self): 1872 return _pywrapcp.Solver___str__(self) 1873 1874 def Add(self, ct): 1875 if isinstance(ct, PyConstraint): 1876 self.__python_constraints.append(ct) 1877 self.AddConstraint(ct) 1878 1879 1880 def TreeNoCycle(self, nexts, active, callback=0): 1881 return _pywrapcp.Solver_TreeNoCycle(self, nexts, active, callback) 1882 1883 def SearchLogWithCallback(self, period, callback): 1884 return _pywrapcp.Solver_SearchLogWithCallback(self, period, callback) 1885 1886 def ElementFunction(self, values, index): 1887 return _pywrapcp.Solver_ElementFunction(self, values, index) 1888 1889 def VarEvalValStrPhase(self, vars, var_evaluator, val_str): 1890 return _pywrapcp.Solver_VarEvalValStrPhase(self, vars, var_evaluator, val_str) 1891 1892 def VarStrValEvalPhase(self, vars, var_str, val_eval): 1893 return _pywrapcp.Solver_VarStrValEvalPhase(self, vars, var_str, val_eval) 1894 1895 def VarEvalValEvalPhase(self, vars, var_eval, val_eval): 1896 return _pywrapcp.Solver_VarEvalValEvalPhase(self, vars, var_eval, val_eval) 1897 1898 def VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker): 1899 return _pywrapcp.Solver_VarStrValEvalTieBreakPhase(self, vars, var_str, val_eval, tie_breaker) 1900 1901 def VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker): 1902 return _pywrapcp.Solver_VarEvalValEvalTieBreakPhase(self, vars, var_eval, val_eval, tie_breaker) 1903 1904 def EvalEvalStrPhase(self, vars, evaluator, str): 1905 return _pywrapcp.Solver_EvalEvalStrPhase(self, vars, evaluator, str) 1906 1907 def EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str): 1908 return _pywrapcp.Solver_EvalEvalStrTieBreakPhase(self, vars, evaluator, tie_breaker, str) 1909 1910 def GuidedLocalSearch(self, *args): 1911 return _pywrapcp.Solver_GuidedLocalSearch(self, *args) 1912 1913 def SumObjectiveFilter(self, vars, values, filter_enum): 1914 return _pywrapcp.Solver_SumObjectiveFilter(self, vars, values, filter_enum)
Solver Class
A solver represents the main computation engine. It implements the entire range of Constraint Programming protocols:
- Reversibility
- Propagation
- Search
Usually, Constraint Programming code consists of
- the creation of the Solver,
- the creation of the decision variables of the model,
- the creation of the constraints of the model and their addition to the solver() through the AddConstraint() method,
- the creation of the main DecisionBuilder class,
- the launch of the solve() method with the decision builder.
For the time being, Solver is neither MT_SAFE nor MT_HOT.
CHOOSE_FIRST_UNBOUND =
2
Select the first unbound variable. Variables are considered in the order of the vector of IntVars used to create the selector.
CHOOSE_MIN_SIZE_LOWEST_MIN =
4
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.
CHOOSE_MIN_SIZE_HIGHEST_MIN =
5
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest min value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.
CHOOSE_MIN_SIZE_LOWEST_MAX =
6
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variables is the one with the lowest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.
CHOOSE_MIN_SIZE_HIGHEST_MAX =
7
Among unbound variables, select the variable with the smallest size, i.e., the smallest number of possible values. In case of a tie, the selected variable is the one with the highest max value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.
CHOOSE_LOWEST_MIN =
8
Among unbound variables, select the variable with the smallest minimal value. In case of a tie, the first one is selected, "first" defined by the order in the vector of IntVars used to create the selector.
CHOOSE_HIGHEST_MAX =
9
Among unbound variables, select the variable with the highest maximal value. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.
CHOOSE_MIN_SIZE =
10
Among unbound variables, select the variable with the smallest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.
CHOOSE_MAX_SIZE =
11
Among unbound variables, select the variable with the highest size. In case of a tie, the first one is selected, first being defined by the order in the vector of IntVars used to create the selector.
CHOOSE_MAX_REGRET_ON_MIN =
12
Among unbound variables, select the variable with the largest gap between the first and the second values of the domain.
CHOOSE_PATH =
13
Selects the next unbound variable on a path, the path being defined by the variables: var[i] corresponds to the index of the next of i.
ASSIGN_CENTER_VALUE =
5
Selects the first possible value which is the closest to the center of the domain of the selected variable. The center is defined as (min + max) / 2.
INTERVAL_SET_TIMES_FORWARD =
2
Selects the variable with the lowest starting time of all variables, and fixes its starting time to this lowest value.
INTERVAL_SET_TIMES_BACKWARD =
3
Selects the variable with the highest ending time of all variables, and fixes the ending time to this highest values.
TWOOPT =
0
Operator which reverses a sub-chain of a path. It is called TwoOpt because it breaks two arcs on the path; resulting paths are called two-optimal. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3 -> 2] -> 4 -> 5 1 -> [4 -> 3 -> 2] -> 5 1 -> 2 -> [4 -> 3] -> 5
OROPT =
1
Relocate: OROPT and RELOCATE. Operator which moves a sub-chain of a path to another position; the specified chain length is the fixed length of the chains being moved. When this length is 1, the operator simply moves a node to another position. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5, for a chain length of 2 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> 4 -> [2 -> 3] -> 5 1 -> [3 -> 4] -> 2 -> 5
Using Relocate with chain lengths of 1, 2 and 3 together is equivalent to the OrOpt operator on a path. The OrOpt operator is a limited version of 3Opt (breaks 3 arcs on a path).
EXCHANGE =
3
Operator which exchanges the positions of two nodes. Possible neighbors for the path 1 -> 2 -> 3 -> 4 -> 5 (where (1, 5) are first and last nodes of the path and can therefore not be moved): 1 -> [3] -> [2] -> 4 -> 5 1 -> [4] -> 3 -> [2] -> 5 1 -> 2 -> [4] -> [3] -> 5
CROSS =
4
Operator which cross exchanges the starting chains of 2 paths, including exchanging the whole paths. First and last nodes are not moved. Possible neighbors for the paths 1 -> 2 -> 3 -> 4 -> 5 and 6 -> 7 -> 8 (where (1, 5) and (6, 8) are first and last nodes of the paths and can therefore not be moved): 1 -> [7] -> 3 -> 4 -> 5 6 -> [2] -> 8 1 -> [7] -> 4 -> 5 6 -> [2 -> 3] -> 8 1 -> [7] -> 5 6 -> [2 -> 3 -> 4] -> 8
MAKEACTIVE =
5
Operator which inserts an inactive node into a path. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 2 -> 3 -> 4 1 -> 2 -> [5] -> 3 -> 4 1 -> 2 -> 3 -> [5] -> 4
MAKEINACTIVE =
6
Operator which makes path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive
MAKECHAININACTIVE =
7
Operator which makes a "chain" of path nodes inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 (where 1 and 4 are first and last nodes of the path) are: 1 -> 3 -> 4 with 2 inactive 1 -> 2 -> 4 with 3 inactive 1 -> 4 with 2 and 3 inactive
SWAPACTIVE =
8
Operator which replaces an active node by an inactive one. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 2 -> [5] -> 4 with 3 inactive
EXTENDEDSWAPACTIVE =
9
Operator which makes an inactive node active and an active one inactive. It is similar to SwapActiveOperator except that it tries to insert the inactive node in all possible positions instead of just the position of the node made inactive. Possible neighbors for the path 1 -> 2 -> 3 -> 4 with 5 inactive (where 1 and 4 are first and last nodes of the path) are: 1 -> [5] -> 3 -> 4 with 2 inactive 1 -> 3 -> [5] -> 4 with 2 inactive 1 -> [5] -> 2 -> 4 with 3 inactive 1 -> 2 -> [5] -> 4 with 3 inactive
PATHLNS =
10
Operator which relaxes two sub-chains of three consecutive arcs each. Each sub-chain is defined by a start node and the next three arcs. Those six arcs are relaxed to build a new neighbor. PATHLNS explores all possible pairs of starting nodes and so defines n^2 neighbors, n being the number of nodes. Note that the two sub-chains can be part of the same path; they even may overlap.
FULLPATHLNS =
11
Operator which relaxes one entire path and all inactive nodes, thus defining num_paths neighbors.
UNACTIVELNS =
12
Operator which relaxes all inactive nodes and one sub-chain of six consecutive arcs. That way the path can be improved by inserting inactive nodes or swapping arcs.
INCREMENT =
13
Operator which defines one neighbor per variable. Each neighbor tries to increment by one the value of the corresponding variable. When a new solution is found the neighborhood is rebuilt from scratch, i.e., tries to increment values in the variable order. Consider for instance variables x and y. x is incremented one by one to its max, and when it is not possible to increment x anymore, y is incremented once. If this is a solution, then next neighbor tries to increment x.
DECREMENT =
14
Operator which defines a neighborhood to decrement values. The behavior is the same as INCREMENT, except values are decremented instead of incremented.
SIMPLELNS =
15
Operator which defines one neighbor per variable. Each neighbor relaxes one variable. When a new solution is found the neighborhood is rebuilt from scratch. Consider for instance variables x and y. First x is relaxed and the solver is looking for the best possible solution (with only x relaxed). Then y is relaxed, and the solver is looking for a new solution. If a new solution is found, then the next variable to be relaxed is x.
EQ =
2
Move is accepted when the current objective value is in the interval objective.Min .. objective.Max.
DELAYED_PRIORITY =
0
DELAYED_PRIORITY is the lowest priority: Demons will be processed after VAR_PRIORITY and NORMAL_PRIORITY demons.
def
Parameters(self):
445 def Parameters(self): 446 r""" Stored Parameters.""" 447 return _pywrapcp.Solver_Parameters(self)
Stored Parameters.
@staticmethod
def
DefaultSolverParameters():
449 @staticmethod 450 def DefaultSolverParameters(): 451 r""" Create a ConstraintSolverParameters proto with all the default values.""" 452 return _pywrapcp.Solver_DefaultSolverParameters()
Create a ConstraintSolverParameters proto with all the default values.
def
AddConstraint(self, c):
454 def AddConstraint(self, c): 455 r""" 456 Adds the constraint 'c' to the model. 457 458 After calling this method, and until there is a backtrack that undoes the 459 addition, any assignment of variables to values must satisfy the given 460 constraint in order to be considered feasible. There are two fairly 461 different use cases: 462 463 - the most common use case is modeling: the given constraint is really 464 part of the problem that the user is trying to solve. In this use case, 465 AddConstraint is called outside of search (i.e., with state() == 466 OUTSIDE_SEARCH). Most users should only use AddConstraint in this 467 way. In this case, the constraint will belong to the model forever: it 468 cannot be removed by backtracking. 469 470 - a rarer use case is that 'c' is not a real constraint of the model. It 471 may be a constraint generated by a branching decision (a constraint whose 472 goal is to restrict the search space), a symmetry breaking constraint (a 473 constraint that does restrict the search space, but in a way that cannot 474 have an impact on the quality of the solutions in the subtree), or an 475 inferred constraint that, while having no semantic value to the model (it 476 does not restrict the set of solutions), is worth having because we 477 believe it may strengthen the propagation. In these cases, it happens 478 that the constraint is added during the search (i.e., with state() == 479 IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is 480 added during a search, it applies only to the subtree of the search tree 481 rooted at the current node, and will be automatically removed by 482 backtracking. 483 484 This method does not take ownership of the constraint. If the constraint 485 has been created by any factory method (Solver::MakeXXX), it will 486 automatically be deleted. However, power users who implement their own 487 constraints should do: solver.AddConstraint(solver.RevAlloc(new 488 MyConstraint(...)); 489 """ 490 return _pywrapcp.Solver_AddConstraint(self, c)
Adds the constraint 'c' to the model.
After calling this method, and until there is a backtrack that undoes the addition, any assignment of variables to values must satisfy the given constraint in order to be considered feasible. There are two fairly different use cases:
the most common use case is modeling: the given constraint is really part of the problem that the user is trying to solve. In this use case, AddConstraint is called outside of search (i.e., with state() == OUTSIDE_SEARCH). Most users should only use AddConstraint in this way. In this case, the constraint will belong to the model forever: it cannot be removed by backtracking.
a rarer use case is that 'c' is not a real constraint of the model. It may be a constraint generated by a branching decision (a constraint whose goal is to restrict the search space), a symmetry breaking constraint (a constraint that does restrict the search space, but in a way that cannot have an impact on the quality of the solutions in the subtree), or an inferred constraint that, while having no semantic value to the model (it does not restrict the set of solutions), is worth having because we believe it may strengthen the propagation. In these cases, it happens that the constraint is added during the search (i.e., with state() == IN_SEARCH or state() == IN_ROOT_NODE). When a constraint is added during a search, it applies only to the subtree of the search tree rooted at the current node, and will be automatically removed by backtracking.
This method does not take ownership of the constraint. If the constraint has been created by any factory method (Solver::MakeXXX), it will automatically be deleted. However, power users who implement their own constraints should do: solver.AddConstraint(solver.RevAlloc(new MyConstraint(...));
def
CheckAssignment(self, solution):
510 def CheckAssignment(self, solution): 511 r""" Checks whether the given assignment satisfies all relevant constraints.""" 512 return _pywrapcp.Solver_CheckAssignment(self, solution)
Checks whether the given assignment satisfies all relevant constraints.
def
CheckConstraint(self, ct):
514 def CheckConstraint(self, ct): 515 r""" 516 Checks whether adding this constraint will lead to an immediate 517 failure. It will return false if the model is already inconsistent, or if 518 adding the constraint makes it inconsistent. 519 """ 520 return _pywrapcp.Solver_CheckConstraint(self, ct)
Checks whether adding this constraint will lead to an immediate failure. It will return false if the model is already inconsistent, or if adding the constraint makes it inconsistent.
def
Fail(self):
522 def Fail(self): 523 r""" Abandon the current branch in the search tree. A backtrack will follow.""" 524 return _pywrapcp.Solver_Fail(self)
Abandon the current branch in the search tree. A backtrack will follow.
@staticmethod
def
MemoryUsage():
526 @staticmethod 527 def MemoryUsage(): 528 r""" Current memory usage in bytes""" 529 return _pywrapcp.Solver_MemoryUsage()
Current memory usage in bytes
def
WallTime(self):
531 def WallTime(self): 532 r""" 533 DEPRECATED: Use Now() instead. 534 Time elapsed, in ms since the creation of the solver. 535 """ 536 return _pywrapcp.Solver_WallTime(self)
DEPRECATED: Use Now() instead. Time elapsed, in ms since the creation of the solver.
def
Branches(self):
538 def Branches(self): 539 r""" The number of branches explored since the creation of the solver.""" 540 return _pywrapcp.Solver_Branches(self)
The number of branches explored since the creation of the solver.
def
Solutions(self):
542 def Solutions(self): 543 r""" The number of solutions found since the start of the search.""" 544 return _pywrapcp.Solver_Solutions(self)
The number of solutions found since the start of the search.
def
Failures(self):
546 def Failures(self): 547 r""" The number of failures encountered since the creation of the solver.""" 548 return _pywrapcp.Solver_Failures(self)
The number of failures encountered since the creation of the solver.
def
AcceptedNeighbors(self):
550 def AcceptedNeighbors(self): 551 r""" The number of accepted neighbors.""" 552 return _pywrapcp.Solver_AcceptedNeighbors(self)
The number of accepted neighbors.
def
Stamp(self):
554 def Stamp(self): 555 r""" 556 The stamp indicates how many moves in the search tree we have performed. 557 It is useful to detect if we need to update same lazy structures. 558 """ 559 return _pywrapcp.Solver_Stamp(self)
The stamp indicates how many moves in the search tree we have performed. It is useful to detect if we need to update same lazy structures.
def
FailStamp(self):
561 def FailStamp(self): 562 r""" The fail_stamp() is incremented after each backtrack.""" 563 return _pywrapcp.Solver_FailStamp(self)
The fail_stamp() is incremented after each backtrack.
def
IntVar(self, *args):
565 def IntVar(self, *args): 566 r""" 567 *Overload 1:* 568 MakeIntVar will create the best range based int var for the bounds given. 569 570 | 571 572 *Overload 2:* 573 MakeIntVar will create a variable with the given sparse domain. 574 575 | 576 577 *Overload 3:* 578 MakeIntVar will create a variable with the given sparse domain. 579 580 | 581 582 *Overload 4:* 583 MakeIntVar will create the best range based int var for the bounds given. 584 585 | 586 587 *Overload 5:* 588 MakeIntVar will create a variable with the given sparse domain. 589 590 | 591 592 *Overload 6:* 593 MakeIntVar will create a variable with the given sparse domain. 594 """ 595 return _pywrapcp.Solver_IntVar(self, *args)
Overload 1: MakeIntVar will create the best range based int var for the bounds given.
|
Overload 2: MakeIntVar will create a variable with the given sparse domain.
|
Overload 3: MakeIntVar will create a variable with the given sparse domain.
|
Overload 4: MakeIntVar will create the best range based int var for the bounds given.
|
Overload 5: MakeIntVar will create a variable with the given sparse domain.
|
Overload 6: MakeIntVar will create a variable with the given sparse domain.
def
BoolVar(self, *args):
597 def BoolVar(self, *args): 598 r""" 599 *Overload 1:* 600 MakeBoolVar will create a variable with a {0, 1} domain. 601 602 | 603 604 *Overload 2:* 605 MakeBoolVar will create a variable with a {0, 1} domain. 606 """ 607 return _pywrapcp.Solver_BoolVar(self, *args)
Overload 1: MakeBoolVar will create a variable with a {0, 1} domain.
|
Overload 2: MakeBoolVar will create a variable with a {0, 1} domain.
def
IntConst(self, *args):
609 def IntConst(self, *args): 610 r""" 611 *Overload 1:* 612 IntConst will create a constant expression. 613 614 | 615 616 *Overload 2:* 617 IntConst will create a constant expression. 618 """ 619 return _pywrapcp.Solver_IntConst(self, *args)
Overload 1: IntConst will create a constant expression.
|
Overload 2: IntConst will create a constant expression.
def
ScalProd(self, *args):
625 def ScalProd(self, *args): 626 r""" 627 *Overload 1:* 628 scalar product 629 630 | 631 632 *Overload 2:* 633 scalar product 634 """ 635 return _pywrapcp.Solver_ScalProd(self, *args)
Overload 1: scalar product
|
Overload 2: scalar product
def
MonotonicElement(self, values, increasing, index):
637 def MonotonicElement(self, values, increasing, index): 638 r""" 639 Function based element. The constraint takes ownership of the 640 callback. The callback must be monotonic. It must be able to 641 cope with any possible value in the domain of 'index' 642 (potentially negative ones too). Furtermore, monotonicity is not 643 checked. Thus giving a non-monotonic function, or specifying an 644 incorrect increasing parameter will result in undefined behavior. 645 """ 646 return _pywrapcp.Solver_MonotonicElement(self, values, increasing, index)
Function based element. The constraint takes ownership of the callback. The callback must be monotonic. It must be able to cope with any possible value in the domain of 'index' (potentially negative ones too). Furtermore, monotonicity is not checked. Thus giving a non-monotonic function, or specifying an incorrect increasing parameter will result in undefined behavior.
def
Element(self, *args):
648 def Element(self, *args): 649 r""" 650 *Overload 1:* 651 values[index] 652 653 | 654 655 *Overload 2:* 656 values[index] 657 658 | 659 660 *Overload 3:* 661 Function-based element. The constraint takes ownership of the 662 callback. The callback must be able to cope with any possible 663 value in the domain of 'index' (potentially negative ones too). 664 665 | 666 667 *Overload 4:* 668 2D version of function-based element expression, values(expr1, expr2). 669 670 | 671 672 *Overload 5:* 673 vars[expr] 674 """ 675 return _pywrapcp.Solver_Element(self, *args)
Overload 1: values[index]
|
Overload 2: values[index]
|
Overload 3: Function-based element. The constraint takes ownership of the callback. The callback must be able to cope with any possible value in the domain of 'index' (potentially negative ones too).
|
Overload 4: 2D version of function-based element expression, values(expr1, expr2).
|
Overload 5: vars[expr]
def
IndexExpression(self, vars, value):
677 def IndexExpression(self, vars, value): 678 r""" 679 Returns the expression expr such that vars[expr] == value. 680 It assumes that vars are all different. 681 """ 682 return _pywrapcp.Solver_IndexExpression(self, vars, value)
Returns the expression expr such that vars[expr] == value. It assumes that vars are all different.
def
Min(self, *args):
684 def Min(self, *args): 685 r""" 686 *Overload 1:* 687 std::min(vars) 688 689 | 690 691 *Overload 2:* 692 std::min (left, right) 693 694 | 695 696 *Overload 3:* 697 std::min(expr, value) 698 699 | 700 701 *Overload 4:* 702 std::min(expr, value) 703 """ 704 return _pywrapcp.Solver_Min(self, *args)
Overload 1: std::min(vars)
|
Overload 2: std::min (left, right)
|
Overload 3: std::min(expr, value)
|
Overload 4: std::min(expr, value)
def
Max(self, *args):
706 def Max(self, *args): 707 r""" 708 *Overload 1:* 709 std::max(vars) 710 711 | 712 713 *Overload 2:* 714 std::max(left, right) 715 716 | 717 718 *Overload 3:* 719 std::max(expr, value) 720 721 | 722 723 *Overload 4:* 724 std::max(expr, value) 725 """ 726 return _pywrapcp.Solver_Max(self, *args)
Overload 1: std::max(vars)
|
Overload 2: std::max(left, right)
|
Overload 3: std::max(expr, value)
|
Overload 4: std::max(expr, value)
def
ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost):
728 def ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost): 729 r""" Convex piecewise function.""" 730 return _pywrapcp.Solver_ConvexPiecewiseExpr(self, expr, early_cost, early_date, late_date, late_cost)
Convex piecewise function.
def
SemiContinuousExpr(self, expr, fixed_charge, step):
732 def SemiContinuousExpr(self, expr, fixed_charge, step): 733 r""" 734 Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) 735 a >= 0 and b >= 0 736 """ 737 return _pywrapcp.Solver_SemiContinuousExpr(self, expr, fixed_charge, step)
Semi continuous Expression (x <= 0 -> f(x) = 0; x > 0 -> f(x) = ax + b) a >= 0 and b >= 0
def
ConditionalExpression(self, condition, expr, unperformed_value):
739 def ConditionalExpression(self, condition, expr, unperformed_value): 740 r""" Conditional Expr condition ? expr : unperformed_value""" 741 return _pywrapcp.Solver_ConditionalExpression(self, condition, expr, unperformed_value)
Conditional Expr condition ? expr : unperformed_value
def
TrueConstraint(self):
743 def TrueConstraint(self): 744 r""" This constraint always succeeds.""" 745 return _pywrapcp.Solver_TrueConstraint(self)
This constraint always succeeds.
def
IsEqualCstCt(self, var, value, boolvar):
750 def IsEqualCstCt(self, var, value, boolvar): 751 r""" boolvar == (var == value)""" 752 return _pywrapcp.Solver_IsEqualCstCt(self, var, value, boolvar)
boolvar == (var == value)
def
IsEqualCstVar(self, var, value):
754 def IsEqualCstVar(self, var, value): 755 r""" status var of (var == value)""" 756 return _pywrapcp.Solver_IsEqualCstVar(self, var, value)
status var of (var == value)
def
IsEqualCt(self, v1, v2, b):
758 def IsEqualCt(self, v1, v2, b): 759 r""" b == (v1 == v2)""" 760 return _pywrapcp.Solver_IsEqualCt(self, v1, v2, b)
b == (v1 == v2)
def
IsEqualVar(self, v1, v2):
762 def IsEqualVar(self, v1, v2): 763 r""" status var of (v1 == v2)""" 764 return _pywrapcp.Solver_IsEqualVar(self, v1, v2)
status var of (v1 == v2)
def
IsDifferentCstCt(self, var, value, boolvar):
766 def IsDifferentCstCt(self, var, value, boolvar): 767 r""" boolvar == (var != value)""" 768 return _pywrapcp.Solver_IsDifferentCstCt(self, var, value, boolvar)
boolvar == (var != value)
def
IsDifferentCstVar(self, var, value):
770 def IsDifferentCstVar(self, var, value): 771 r""" status var of (var != value)""" 772 return _pywrapcp.Solver_IsDifferentCstVar(self, var, value)
status var of (var != value)
def
IsDifferentVar(self, v1, v2):
774 def IsDifferentVar(self, v1, v2): 775 r""" status var of (v1 != v2)""" 776 return _pywrapcp.Solver_IsDifferentVar(self, v1, v2)
status var of (v1 != v2)
def
IsDifferentCt(self, v1, v2, b):
778 def IsDifferentCt(self, v1, v2, b): 779 r""" b == (v1 != v2)""" 780 return _pywrapcp.Solver_IsDifferentCt(self, v1, v2, b)
b == (v1 != v2)
def
IsLessOrEqualCstCt(self, var, value, boolvar):
782 def IsLessOrEqualCstCt(self, var, value, boolvar): 783 r""" boolvar == (var <= value)""" 784 return _pywrapcp.Solver_IsLessOrEqualCstCt(self, var, value, boolvar)
boolvar == (var <= value)
def
IsLessOrEqualCstVar(self, var, value):
786 def IsLessOrEqualCstVar(self, var, value): 787 r""" status var of (var <= value)""" 788 return _pywrapcp.Solver_IsLessOrEqualCstVar(self, var, value)
status var of (var <= value)
def
IsLessOrEqualVar(self, left, right):
790 def IsLessOrEqualVar(self, left, right): 791 r""" status var of (left <= right)""" 792 return _pywrapcp.Solver_IsLessOrEqualVar(self, left, right)
status var of (left <= right)
def
IsLessOrEqualCt(self, left, right, b):
794 def IsLessOrEqualCt(self, left, right, b): 795 r""" b == (left <= right)""" 796 return _pywrapcp.Solver_IsLessOrEqualCt(self, left, right, b)
b == (left <= right)
def
IsGreaterOrEqualCstCt(self, var, value, boolvar):
798 def IsGreaterOrEqualCstCt(self, var, value, boolvar): 799 r""" boolvar == (var >= value)""" 800 return _pywrapcp.Solver_IsGreaterOrEqualCstCt(self, var, value, boolvar)
boolvar == (var >= value)
def
IsGreaterOrEqualCstVar(self, var, value):
802 def IsGreaterOrEqualCstVar(self, var, value): 803 r""" status var of (var >= value)""" 804 return _pywrapcp.Solver_IsGreaterOrEqualCstVar(self, var, value)
status var of (var >= value)
def
IsGreaterOrEqualVar(self, left, right):
806 def IsGreaterOrEqualVar(self, left, right): 807 r""" status var of (left >= right)""" 808 return _pywrapcp.Solver_IsGreaterOrEqualVar(self, left, right)
status var of (left >= right)
def
IsGreaterOrEqualCt(self, left, right, b):
810 def IsGreaterOrEqualCt(self, left, right, b): 811 r""" b == (left >= right)""" 812 return _pywrapcp.Solver_IsGreaterOrEqualCt(self, left, right, b)
b == (left >= right)
def
IsGreaterCstCt(self, v, c, b):
814 def IsGreaterCstCt(self, v, c, b): 815 r""" b == (v > c)""" 816 return _pywrapcp.Solver_IsGreaterCstCt(self, v, c, b)
b == (v > c)
def
IsGreaterCstVar(self, var, value):
818 def IsGreaterCstVar(self, var, value): 819 r""" status var of (var > value)""" 820 return _pywrapcp.Solver_IsGreaterCstVar(self, var, value)
status var of (var > value)
def
IsGreaterVar(self, left, right):
822 def IsGreaterVar(self, left, right): 823 r""" status var of (left > right)""" 824 return _pywrapcp.Solver_IsGreaterVar(self, left, right)
status var of (left > right)
def
IsGreaterCt(self, left, right, b):
826 def IsGreaterCt(self, left, right, b): 827 r""" b == (left > right)""" 828 return _pywrapcp.Solver_IsGreaterCt(self, left, right, b)
b == (left > right)
def
IsLessCstCt(self, v, c, b):
830 def IsLessCstCt(self, v, c, b): 831 r""" b == (v < c)""" 832 return _pywrapcp.Solver_IsLessCstCt(self, v, c, b)
b == (v < c)
def
IsLessCstVar(self, var, value):
834 def IsLessCstVar(self, var, value): 835 r""" status var of (var < value)""" 836 return _pywrapcp.Solver_IsLessCstVar(self, var, value)
status var of (var < value)
def
IsLessVar(self, left, right):
838 def IsLessVar(self, left, right): 839 r""" status var of (left < right)""" 840 return _pywrapcp.Solver_IsLessVar(self, left, right)
status var of (left < right)
def
IsLessCt(self, left, right, b):
842 def IsLessCt(self, left, right, b): 843 r""" b == (left < right)""" 844 return _pywrapcp.Solver_IsLessCt(self, left, right, b)
b == (left < right)
def
SumLessOrEqual(self, vars, cst):
846 def SumLessOrEqual(self, vars, cst): 847 r""" Variation on arrays.""" 848 return _pywrapcp.Solver_SumLessOrEqual(self, vars, cst)
Variation on arrays.
def
AbsEquality(self, var, abs_var):
874 def AbsEquality(self, var, abs_var): 875 r""" Creates the constraint abs(var) == abs_var.""" 876 return _pywrapcp.Solver_AbsEquality(self, var, abs_var)
Creates the constraint abs(var) == abs_var.
def
IndexOfConstraint(self, vars, index, target):
878 def IndexOfConstraint(self, vars, index, target): 879 r""" 880 This constraint is a special case of the element constraint with 881 an array of integer variables, where the variables are all 882 different and the index variable is constrained such that 883 vars[index] == target. 884 """ 885 return _pywrapcp.Solver_IndexOfConstraint(self, vars, index, target)
This constraint is a special case of the element constraint with an array of integer variables, where the variables are all different and the index variable is constrained such that vars[index] == target.
def
ConstraintInitialPropagateCallback(self, ct):
887 def ConstraintInitialPropagateCallback(self, ct): 888 r""" 889 This method is a specialized case of the MakeConstraintDemon 890 method to call the InitiatePropagate of the constraint 'ct'. 891 """ 892 return _pywrapcp.Solver_ConstraintInitialPropagateCallback(self, ct)
This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct'.
def
DelayedConstraintInitialPropagateCallback(self, ct):
894 def DelayedConstraintInitialPropagateCallback(self, ct): 895 r""" 896 This method is a specialized case of the MakeConstraintDemon 897 method to call the InitiatePropagate of the constraint 'ct' with 898 low priority. 899 """ 900 return _pywrapcp.Solver_DelayedConstraintInitialPropagateCallback(self, ct)
This method is a specialized case of the MakeConstraintDemon method to call the InitiatePropagate of the constraint 'ct' with low priority.
def
ClosureDemon(self, closure):
902 def ClosureDemon(self, closure): 903 r""" Creates a demon from a closure.""" 904 return _pywrapcp.Solver_ClosureDemon(self, closure)
Creates a demon from a closure.
def
BetweenCt(self, expr, l, u):
906 def BetweenCt(self, expr, l, u): 907 r""" (l <= expr <= u)""" 908 return _pywrapcp.Solver_BetweenCt(self, expr, l, u)
(l <= expr <= u)
def
IsBetweenCt(self, expr, l, u, b):
910 def IsBetweenCt(self, expr, l, u, b): 911 r""" b == (l <= expr <= u)""" 912 return _pywrapcp.Solver_IsBetweenCt(self, expr, l, u, b)
b == (l <= expr <= u)
def
NotMemberCt(self, *args):
920 def NotMemberCt(self, *args): 921 r""" 922 *Overload 1:* 923 expr not in set. 924 925 | 926 927 *Overload 2:* 928 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 929 930 | 931 932 *Overload 3:* 933 expr should not be in the list of forbidden intervals [start[i]..end[i]]. 934 """ 935 return _pywrapcp.Solver_NotMemberCt(self, *args)
Overload 1: expr not in set.
|
Overload 2: expr should not be in the list of forbidden intervals [start[i]..end[i]].
|
Overload 3: expr should not be in the list of forbidden intervals [start[i]..end[i]].
def
Count(self, *args):
943 def Count(self, *args): 944 r""" 945 *Overload 1:* 946 |{i | vars[i] == value}| == max_count 947 948 | 949 950 *Overload 2:* 951 |{i | vars[i] == value}| == max_count 952 """ 953 return _pywrapcp.Solver_Count(self, *args)
Overload 1: |{i | vars[i] == value}| == max_count
|
Overload 2: |{i | vars[i] == value}| == max_count
def
Distribute(self, *args):
955 def Distribute(self, *args): 956 r""" 957 *Overload 1:* 958 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 959 960 | 961 962 *Overload 2:* 963 Aggregated version of count: |{i | v[i] == values[j]}| == cards[j] 964 965 | 966 967 *Overload 3:* 968 Aggregated version of count: |{i | v[i] == j}| == cards[j] 969 970 | 971 972 *Overload 4:* 973 Aggregated version of count with bounded cardinalities: 974 forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max 975 976 | 977 978 *Overload 5:* 979 Aggregated version of count with bounded cardinalities: 980 forall j in 0 .. card_size - 1: 981 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 982 983 | 984 985 *Overload 6:* 986 Aggregated version of count with bounded cardinalities: 987 forall j in 0 .. card_size - 1: 988 card_min[j] <= |{i | v[i] == j}| <= card_max[j] 989 990 | 991 992 *Overload 7:* 993 Aggregated version of count with bounded cardinalities: 994 forall j in 0 .. card_size - 1: 995 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 996 997 | 998 999 *Overload 8:* 1000 Aggregated version of count with bounded cardinalities: 1001 forall j in 0 .. card_size - 1: 1002 card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j] 1003 """ 1004 return _pywrapcp.Solver_Distribute(self, *args)
Overload 1: Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
Overload 2: Aggregated version of count: |{i | v[i] == values[j]}| == cards[j]
|
Overload 3: Aggregated version of count: |{i | v[i] == j}| == cards[j]
|
Overload 4: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min <= |{i | v[i] == j}| <= card_max
|
Overload 5: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
Overload 6: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == j}| <= card_max[j]
|
Overload 7: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
|
Overload 8: Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= |{i | v[i] == values[j]}| <= card_max[j]
def
Deviation(self, vars, deviation_var, total_sum):
1006 def Deviation(self, vars, deviation_var, total_sum): 1007 r""" 1008 Deviation constraint: 1009 sum_i |n * vars[i] - total_sum| <= deviation_var and 1010 sum_i vars[i] == total_sum 1011 n = #vars 1012 """ 1013 return _pywrapcp.Solver_Deviation(self, vars, deviation_var, total_sum)
Deviation constraint: sum_i |n * vars[i] - total_sum| <= deviation_var and sum_i vars[i] == total_sum n = #vars
def
AllDifferent(self, *args):
1015 def AllDifferent(self, *args): 1016 r""" 1017 *Overload 1:* 1018 All variables are pairwise different. This corresponds to the 1019 stronger version of the propagation algorithm. 1020 1021 | 1022 1023 *Overload 2:* 1024 All variables are pairwise different. If 'stronger_propagation' 1025 is true, stronger, and potentially slower propagation will 1026 occur. This API will be deprecated in the future. 1027 """ 1028 return _pywrapcp.Solver_AllDifferent(self, *args)
Overload 1: All variables are pairwise different. This corresponds to the stronger version of the propagation algorithm.
|
Overload 2: All variables are pairwise different. If 'stronger_propagation' is true, stronger, and potentially slower propagation will occur. This API will be deprecated in the future.
def
AllDifferentExcept(self, vars, escape_value):
1030 def AllDifferentExcept(self, vars, escape_value): 1031 r""" 1032 All variables are pairwise different, unless they are assigned to 1033 the escape value. 1034 """ 1035 return _pywrapcp.Solver_AllDifferentExcept(self, vars, escape_value)
All variables are pairwise different, unless they are assigned to the escape value.
def
SortingConstraint(self, vars, sorted):
1037 def SortingConstraint(self, vars, sorted): 1038 r""" 1039 Creates a constraint binding the arrays of variables "vars" and 1040 "sorted_vars": sorted_vars[0] must be equal to the minimum of all 1041 variables in vars, and so on: the value of sorted_vars[i] must be 1042 equal to the i-th value of variables invars. 1043 1044 This constraint propagates in both directions: from "vars" to 1045 "sorted_vars" and vice-versa. 1046 1047 Behind the scenes, this constraint maintains that: 1048 - sorted is always increasing. 1049 - whatever the values of vars, there exists a permutation that 1050 injects its values into the sorted variables. 1051 1052 For more info, please have a look at: 1053 https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf 1054 """ 1055 return _pywrapcp.Solver_SortingConstraint(self, vars, sorted)
Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars.
This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa.
Behind the scenes, this constraint maintains that:
- sorted is always increasing.
- whatever the values of vars, there exists a permutation that injects its values into the sorted variables.
For more info, please have a look at: https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf
def
LexicalLess(self, left, right):
1057 def LexicalLess(self, left, right): 1058 r""" 1059 Creates a constraint that enforces that left is lexicographically less 1060 than right. 1061 """ 1062 return _pywrapcp.Solver_LexicalLess(self, left, right)
Creates a constraint that enforces that left is lexicographically less than right.
def
LexicalLessOrEqual(self, left, right):
1064 def LexicalLessOrEqual(self, left, right): 1065 r""" 1066 Creates a constraint that enforces that left is lexicographically less 1067 than or equal to right. 1068 """ 1069 return _pywrapcp.Solver_LexicalLessOrEqual(self, left, right)
Creates a constraint that enforces that left is lexicographically less than or equal to right.
def
InversePermutationConstraint(self, left, right):
1071 def InversePermutationConstraint(self, left, right): 1072 r""" 1073 Creates a constraint that enforces that 'left' and 'right' both 1074 represent permutations of [0..left.size()-1], and that 'right' is 1075 the inverse permutation of 'left', i.e. for all i in 1076 [0..left.size()-1], right[left[i]] = i. 1077 """ 1078 return _pywrapcp.Solver_InversePermutationConstraint(self, left, right)
Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e. for all i in [0..left.size()-1], right[left[i]] = i.
def
NullIntersect(self, first_vars, second_vars):
1080 def NullIntersect(self, first_vars, second_vars): 1081 r""" 1082 Creates a constraint that states that all variables in the first 1083 vector are different from all variables in the second 1084 group. Thus the set of values in the first vector does not 1085 intersect with the set of values in the second vector. 1086 """ 1087 return _pywrapcp.Solver_NullIntersect(self, first_vars, second_vars)
Creates a constraint that states that all variables in the first vector are different from all variables in the second group. Thus the set of values in the first vector does not intersect with the set of values in the second vector.
def
NullIntersectExcept(self, first_vars, second_vars, escape_value):
1089 def NullIntersectExcept(self, first_vars, second_vars, escape_value): 1090 r""" 1091 Creates a constraint that states that all variables in the first 1092 vector are different from all variables from the second group, 1093 unless they are assigned to the escape value. Thus the set of 1094 values in the first vector minus the escape value does not 1095 intersect with the set of values in the second vector. 1096 """ 1097 return _pywrapcp.Solver_NullIntersectExcept(self, first_vars, second_vars, escape_value)
Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value. Thus the set of values in the first vector minus the escape value does not intersect with the set of values in the second vector.
def
Circuit(self, nexts):
1099 def Circuit(self, nexts): 1100 r""" Force the "nexts" variable to create a complete Hamiltonian path.""" 1101 return _pywrapcp.Solver_Circuit(self, nexts)
Force the "nexts" variable to create a complete Hamiltonian path.
def
SubCircuit(self, nexts):
1103 def SubCircuit(self, nexts): 1104 r""" 1105 Force the "nexts" variable to create a complete Hamiltonian path 1106 for those that do not loop upon themselves. 1107 """ 1108 return _pywrapcp.Solver_SubCircuit(self, nexts)
Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves.
def
DelayedPathCumul(self, nexts, active, cumuls, transits):
1110 def DelayedPathCumul(self, nexts, active, cumuls, transits): 1111 r""" 1112 Delayed version of the same constraint: propagation on the nexts variables 1113 is delayed until all constraints have propagated. 1114 """ 1115 return _pywrapcp.Solver_DelayedPathCumul(self, nexts, active, cumuls, transits)
Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated.
def
PathCumul(self, *args):
1117 def PathCumul(self, *args): 1118 r""" 1119 *Overload 1:* 1120 Creates a constraint which accumulates values along a path such that: 1121 cumuls[next[i]] = cumuls[i] + transits[i]. 1122 Active variables indicate if the corresponding next variable is active; 1123 this could be useful to model unperformed nodes in a routing problem. 1124 1125 | 1126 1127 *Overload 2:* 1128 Creates a constraint which accumulates values along a path such that: 1129 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). 1130 Active variables indicate if the corresponding next variable is active; 1131 this could be useful to model unperformed nodes in a routing problem. 1132 Ownership of transit_evaluator is taken and it must be a repeatable 1133 callback. 1134 1135 | 1136 1137 *Overload 3:* 1138 Creates a constraint which accumulates values along a path such that: 1139 cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. 1140 Active variables indicate if the corresponding next variable is active; 1141 this could be useful to model unperformed nodes in a routing problem. 1142 Ownership of transit_evaluator is taken and it must be a repeatable 1143 callback. 1144 """ 1145 return _pywrapcp.Solver_PathCumul(self, *args)
Overload 1: Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.
|
Overload 2: Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
|
Overload 3: Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
def
AllowedAssignments(self, *args):
1147 def AllowedAssignments(self, *args): 1148 r""" 1149 *Overload 1:* 1150 This method creates a constraint where the graph of the relation 1151 between the variables is given in extension. There are 'arity' 1152 variables involved in the relation and the graph is given by a 1153 integer tuple set. 1154 1155 | 1156 1157 *Overload 2:* 1158 Compatibility layer for Python API. 1159 """ 1160 return _pywrapcp.Solver_AllowedAssignments(self, *args)
Overload 1: This method creates a constraint where the graph of the relation between the variables is given in extension. There are 'arity' variables involved in the relation and the graph is given by a integer tuple set.
|
Overload 2: Compatibility layer for Python API.
def
Pack(self, vars, number_of_bins):
1168 def Pack(self, vars, number_of_bins): 1169 r""" 1170 This constraint packs all variables onto 'number_of_bins' 1171 variables. For any given variable, a value of 'number_of_bins' 1172 indicates that the variable is not assigned to any bin. 1173 Dimensions, i.e., cumulative constraints on this packing, can be 1174 added directly from the pack class. 1175 """ 1176 return _pywrapcp.Solver_Pack(self, vars, number_of_bins)
This constraint packs all variables onto 'number_of_bins' variables. For any given variable, a value of 'number_of_bins' indicates that the variable is not assigned to any bin. Dimensions, i.e., cumulative constraints on this packing, can be added directly from the pack class.
def
FixedDurationIntervalVar(self, *args):
1178 def FixedDurationIntervalVar(self, *args): 1179 r""" 1180 *Overload 1:* 1181 Creates an interval var with a fixed duration. The duration must 1182 be greater than 0. If optional is true, then the interval can be 1183 performed or unperformed. If optional is false, then the interval 1184 is always performed. 1185 1186 | 1187 1188 *Overload 2:* 1189 Creates a performed interval var with a fixed duration. The duration must 1190 be greater than 0. 1191 1192 | 1193 1194 *Overload 3:* 1195 Creates an interval var with a fixed duration, and performed_variable. 1196 The duration must be greater than 0. 1197 """ 1198 return _pywrapcp.Solver_FixedDurationIntervalVar(self, *args)
Overload 1: Creates an interval var with a fixed duration. The duration must be greater than 0. If optional is true, then the interval can be performed or unperformed. If optional is false, then the interval is always performed.
|
Overload 2: Creates a performed interval var with a fixed duration. The duration must be greater than 0.
|
Overload 3: Creates an interval var with a fixed duration, and performed_variable. The duration must be greater than 0.
def
FixedInterval(self, start, duration, name):
1200 def FixedInterval(self, start, duration, name): 1201 r""" Creates a fixed and performed interval.""" 1202 return _pywrapcp.Solver_FixedInterval(self, start, duration, name)
Creates a fixed and performed interval.
def
IntervalVar( self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name):
1204 def IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name): 1205 r""" 1206 Creates an interval var by specifying the bounds on start, 1207 duration, and end. 1208 """ 1209 return _pywrapcp.Solver_IntervalVar(self, start_min, start_max, duration_min, duration_max, end_min, end_max, optional, name)
Creates an interval var by specifying the bounds on start, duration, and end.
def
MirrorInterval(self, interval_var):
1211 def MirrorInterval(self, interval_var): 1212 r""" 1213 Creates an interval var that is the mirror image of the given one, that 1214 is, the interval var obtained by reversing the axis. 1215 """ 1216 return _pywrapcp.Solver_MirrorInterval(self, interval_var)
Creates an interval var that is the mirror image of the given one, that is, the interval var obtained by reversing the axis.
def
FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1218 def FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1219 r""" 1220 Creates an interval var with a fixed duration whose start is 1221 synchronized with the start of another interval, with a given 1222 offset. The performed status is also in sync with the performed 1223 status of the given interval variable. 1224 """ 1225 return _pywrapcp.Solver_FixedDurationStartSyncedOnStartIntervalVar(self, interval_var, duration, offset)
Creates an interval var with a fixed duration whose start is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.
def
FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1227 def FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1228 r""" 1229 Creates an interval var with a fixed duration whose start is 1230 synchronized with the end of another interval, with a given 1231 offset. The performed status is also in sync with the performed 1232 status of the given interval variable. 1233 """ 1234 return _pywrapcp.Solver_FixedDurationStartSyncedOnEndIntervalVar(self, interval_var, duration, offset)
Creates an interval var with a fixed duration whose start is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.
def
FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset):
1236 def FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset): 1237 r""" 1238 Creates an interval var with a fixed duration whose end is 1239 synchronized with the start of another interval, with a given 1240 offset. The performed status is also in sync with the performed 1241 status of the given interval variable. 1242 """ 1243 return _pywrapcp.Solver_FixedDurationEndSyncedOnStartIntervalVar(self, interval_var, duration, offset)
Creates an interval var with a fixed duration whose end is synchronized with the start of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.
def
FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset):
1245 def FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset): 1246 r""" 1247 Creates an interval var with a fixed duration whose end is 1248 synchronized with the end of another interval, with a given 1249 offset. The performed status is also in sync with the performed 1250 status of the given interval variable. 1251 """ 1252 return _pywrapcp.Solver_FixedDurationEndSyncedOnEndIntervalVar(self, interval_var, duration, offset)
Creates an interval var with a fixed duration whose end is synchronized with the end of another interval, with a given offset. The performed status is also in sync with the performed status of the given interval variable.
def
IntervalRelaxedMin(self, interval_var):
1254 def IntervalRelaxedMin(self, interval_var): 1255 r""" 1256 Creates and returns an interval variable that wraps around the given one, 1257 relaxing the min start and end. Relaxing means making unbounded when 1258 optional. If the variable is non-optional, this method returns 1259 interval_var. 1260 1261 More precisely, such an interval variable behaves as follows: 1262 When the underlying must be performed, the returned interval variable 1263 behaves exactly as the underlying; 1264 When the underlying may or may not be performed, the returned interval 1265 variable behaves like the underlying, except that it is unbounded on 1266 the min side; 1267 When the underlying cannot be performed, the returned interval variable 1268 is of duration 0 and must be performed in an interval unbounded on 1269 both sides. 1270 1271 This is very useful to implement propagators that may only modify 1272 the start max or end max. 1273 """ 1274 return _pywrapcp.Solver_IntervalRelaxedMin(self, interval_var)
Creates and returns an interval variable that wraps around the given one, relaxing the min start and end. Relaxing means making unbounded when optional. If the variable is non-optional, this method returns interval_var.
More precisely, such an interval variable behaves as follows: When the underlying must be performed, the returned interval variable behaves exactly as the underlying; When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the min side; When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides.
This is very useful to implement propagators that may only modify the start max or end max.
def
IntervalRelaxedMax(self, interval_var):
1276 def IntervalRelaxedMax(self, interval_var): 1277 r""" 1278 Creates and returns an interval variable that wraps around the given one, 1279 relaxing the max start and end. Relaxing means making unbounded when 1280 optional. If the variable is non optional, this method returns 1281 interval_var. 1282 1283 More precisely, such an interval variable behaves as follows: 1284 When the underlying must be performed, the returned interval variable 1285 behaves exactly as the underlying; 1286 When the underlying may or may not be performed, the returned interval 1287 variable behaves like the underlying, except that it is unbounded on 1288 the max side; 1289 When the underlying cannot be performed, the returned interval variable 1290 is of duration 0 and must be performed in an interval unbounded on 1291 both sides. 1292 1293 This is very useful for implementing propagators that may only modify 1294 the start min or end min. 1295 """ 1296 return _pywrapcp.Solver_IntervalRelaxedMax(self, interval_var)
Creates and returns an interval variable that wraps around the given one, relaxing the max start and end. Relaxing means making unbounded when optional. If the variable is non optional, this method returns interval_var.
More precisely, such an interval variable behaves as follows: When the underlying must be performed, the returned interval variable behaves exactly as the underlying; When the underlying may or may not be performed, the returned interval variable behaves like the underlying, except that it is unbounded on the max side; When the underlying cannot be performed, the returned interval variable is of duration 0 and must be performed in an interval unbounded on both sides.
This is very useful for implementing propagators that may only modify the start min or end min.
def
TemporalDisjunction(self, *args):
1298 def TemporalDisjunction(self, *args): 1299 r""" 1300 *Overload 1:* 1301 This constraint implements a temporal disjunction between two 1302 interval vars t1 and t2. 'alt' indicates which alternative was 1303 chosen (alt == 0 is equivalent to t1 before t2). 1304 1305 | 1306 1307 *Overload 2:* 1308 This constraint implements a temporal disjunction between two 1309 interval vars. 1310 """ 1311 return _pywrapcp.Solver_TemporalDisjunction(self, *args)
Overload 1: This constraint implements a temporal disjunction between two interval vars t1 and t2. 'alt' indicates which alternative was chosen (alt == 0 is equivalent to t1 before t2).
|
Overload 2: This constraint implements a temporal disjunction between two interval vars.
def
DisjunctiveConstraint(self, intervals, name):
1313 def DisjunctiveConstraint(self, intervals, name): 1314 r""" 1315 This constraint forces all interval vars into an non-overlapping 1316 sequence. Intervals with zero duration can be scheduled anywhere. 1317 """ 1318 return _pywrapcp.Solver_DisjunctiveConstraint(self, intervals, name)
This constraint forces all interval vars into an non-overlapping sequence. Intervals with zero duration can be scheduled anywhere.
def
Cumulative(self, *args):
1320 def Cumulative(self, *args): 1321 r""" 1322 *Overload 1:* 1323 This constraint forces that, for any integer t, the sum of the demands 1324 corresponding to an interval containing t does not exceed the given 1325 capacity. 1326 1327 Intervals and demands should be vectors of equal size. 1328 1329 Demands should only contain non-negative values. Zero values are 1330 supported, and the corresponding intervals are filtered out, as they 1331 neither impact nor are impacted by this constraint. 1332 1333 | 1334 1335 *Overload 2:* 1336 This constraint forces that, for any integer t, the sum of the demands 1337 corresponding to an interval containing t does not exceed the given 1338 capacity. 1339 1340 Intervals and demands should be vectors of equal size. 1341 1342 Demands should only contain non-negative values. Zero values are 1343 supported, and the corresponding intervals are filtered out, as they 1344 neither impact nor are impacted by this constraint. 1345 1346 | 1347 1348 *Overload 3:* 1349 This constraint forces that, for any integer t, the sum of the demands 1350 corresponding to an interval containing t does not exceed the given 1351 capacity. 1352 1353 Intervals and demands should be vectors of equal size. 1354 1355 Demands should only contain non-negative values. Zero values are 1356 supported, and the corresponding intervals are filtered out, as they 1357 neither impact nor are impacted by this constraint. 1358 1359 | 1360 1361 *Overload 4:* 1362 This constraint enforces that, for any integer t, the sum of the demands 1363 corresponding to an interval containing t does not exceed the given 1364 capacity. 1365 1366 Intervals and demands should be vectors of equal size. 1367 1368 Demands should only contain non-negative values. Zero values are 1369 supported, and the corresponding intervals are filtered out, as they 1370 neither impact nor are impacted by this constraint. 1371 1372 | 1373 1374 *Overload 5:* 1375 This constraint enforces that, for any integer t, the sum of demands 1376 corresponding to an interval containing t does not exceed the given 1377 capacity. 1378 1379 Intervals and demands should be vectors of equal size. 1380 1381 Demands should be positive. 1382 1383 | 1384 1385 *Overload 6:* 1386 This constraint enforces that, for any integer t, the sum of demands 1387 corresponding to an interval containing t does not exceed the given 1388 capacity. 1389 1390 Intervals and demands should be vectors of equal size. 1391 1392 Demands should be positive. 1393 """ 1394 return _pywrapcp.Solver_Cumulative(self, *args)
Overload 1: This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.
Intervals and demands should be vectors of equal size.
Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
Overload 2: This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.
Intervals and demands should be vectors of equal size.
Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
Overload 3: This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.
Intervals and demands should be vectors of equal size.
Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
Overload 4: This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity.
Intervals and demands should be vectors of equal size.
Demands should only contain non-negative values. Zero values are supported, and the corresponding intervals are filtered out, as they neither impact nor are impacted by this constraint.
|
Overload 5: This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity.
Intervals and demands should be vectors of equal size.
Demands should be positive.
|
Overload 6: This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity.
Intervals and demands should be vectors of equal size.
Demands should be positive.
def
Cover(self, vars, target_var):
1396 def Cover(self, vars, target_var): 1397 r""" 1398 This constraint states that the target_var is the convex hull of 1399 the intervals. If none of the interval variables is performed, 1400 then the target var is unperformed too. Also, if the target 1401 variable is unperformed, then all the intervals variables are 1402 unperformed too. 1403 """ 1404 return _pywrapcp.Solver_Cover(self, vars, target_var)
This constraint states that the target_var is the convex hull of the intervals. If none of the interval variables is performed, then the target var is unperformed too. Also, if the target variable is unperformed, then all the intervals variables are unperformed too.
def
Assignment(self, *args):
1406 def Assignment(self, *args): 1407 r""" 1408 *Overload 1:* 1409 This method creates an empty assignment. 1410 1411 | 1412 1413 *Overload 2:* 1414 This method creates an assignment which is a copy of 'a'. 1415 """ 1416 return _pywrapcp.Solver_Assignment(self, *args)
Overload 1: This method creates an empty assignment.
|
Overload 2: This method creates an assignment which is a copy of 'a'.
def
FirstSolutionCollector(self, *args):
1418 def FirstSolutionCollector(self, *args): 1419 r""" 1420 *Overload 1:* 1421 Collect the first solution of the search. 1422 1423 | 1424 1425 *Overload 2:* 1426 Collect the first solution of the search. The variables will need to 1427 be added later. 1428 """ 1429 return _pywrapcp.Solver_FirstSolutionCollector(self, *args)
Overload 1: Collect the first solution of the search.
|
Overload 2: Collect the first solution of the search. The variables will need to be added later.
def
LastSolutionCollector(self, *args):
1431 def LastSolutionCollector(self, *args): 1432 r""" 1433 *Overload 1:* 1434 Collect the last solution of the search. 1435 1436 | 1437 1438 *Overload 2:* 1439 Collect the last solution of the search. The variables will need to 1440 be added later. 1441 """ 1442 return _pywrapcp.Solver_LastSolutionCollector(self, *args)
Overload 1: Collect the last solution of the search.
|
Overload 2: Collect the last solution of the search. The variables will need to be added later.
def
BestValueSolutionCollector(self, *args):
1444 def BestValueSolutionCollector(self, *args): 1445 r""" 1446 *Overload 1:* 1447 Collect the solution corresponding to the optimal value of the objective 1448 of 'assignment'; if 'assignment' does not have an objective no solution is 1449 collected. This collector only collects one solution corresponding to the 1450 best objective value (the first one found). 1451 1452 | 1453 1454 *Overload 2:* 1455 Collect the solution corresponding to the optimal value of the 1456 objective of the internal assignment; if this assignment does not have an 1457 objective no solution is collected. This collector only collects one 1458 solution corresponding to the best objective value (the first one found). 1459 The variables and objective(s) will need to be added later. 1460 """ 1461 return _pywrapcp.Solver_BestValueSolutionCollector(self, *args)
Overload 1: Collect the solution corresponding to the optimal value of the objective of 'assignment'; if 'assignment' does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found).
|
Overload 2: Collect the solution corresponding to the optimal value of the objective of the internal assignment; if this assignment does not have an objective no solution is collected. This collector only collects one solution corresponding to the best objective value (the first one found). The variables and objective(s) will need to be added later.
def
AllSolutionCollector(self, *args):
1463 def AllSolutionCollector(self, *args): 1464 r""" 1465 *Overload 1:* 1466 Collect all solutions of the search. 1467 1468 | 1469 1470 *Overload 2:* 1471 Collect all solutions of the search. The variables will need to 1472 be added later. 1473 """ 1474 return _pywrapcp.Solver_AllSolutionCollector(self, *args)
Overload 1: Collect all solutions of the search.
|
Overload 2: Collect all solutions of the search. The variables will need to be added later.
def
Minimize(self, v, step):
1476 def Minimize(self, v, step): 1477 r""" Creates a minimization objective.""" 1478 return _pywrapcp.Solver_Minimize(self, v, step)
Creates a minimization objective.
def
Maximize(self, v, step):
1480 def Maximize(self, v, step): 1481 r""" Creates a maximization objective.""" 1482 return _pywrapcp.Solver_Maximize(self, v, step)
Creates a maximization objective.
def
Optimize(self, maximize, v, step):
1484 def Optimize(self, maximize, v, step): 1485 r""" Creates a objective with a given sense (true = maximization).""" 1486 return _pywrapcp.Solver_Optimize(self, maximize, v, step)
Creates a objective with a given sense (true = maximization).
def
WeightedMinimize(self, *args):
1488 def WeightedMinimize(self, *args): 1489 r""" 1490 *Overload 1:* 1491 Creates a minimization weighted objective. The actual objective is 1492 scalar_prod(sub_objectives, weights). 1493 1494 | 1495 1496 *Overload 2:* 1497 Creates a minimization weighted objective. The actual objective is 1498 scalar_prod(sub_objectives, weights). 1499 """ 1500 return _pywrapcp.Solver_WeightedMinimize(self, *args)
Overload 1: Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
|
Overload 2: Creates a minimization weighted objective. The actual objective is scalar_prod(sub_objectives, weights).
def
WeightedMaximize(self, *args):
1502 def WeightedMaximize(self, *args): 1503 r""" 1504 *Overload 1:* 1505 Creates a maximization weigthed objective. 1506 1507 | 1508 1509 *Overload 2:* 1510 Creates a maximization weigthed objective. 1511 """ 1512 return _pywrapcp.Solver_WeightedMaximize(self, *args)
Overload 1: Creates a maximization weigthed objective.
|
Overload 2: Creates a maximization weigthed objective.
def
WeightedOptimize(self, *args):
1514 def WeightedOptimize(self, *args): 1515 r""" 1516 *Overload 1:* 1517 Creates a weighted objective with a given sense (true = maximization). 1518 1519 | 1520 1521 *Overload 2:* 1522 Creates a weighted objective with a given sense (true = maximization). 1523 """ 1524 return _pywrapcp.Solver_WeightedOptimize(self, *args)
Overload 1: Creates a weighted objective with a given sense (true = maximization).
|
Overload 2: Creates a weighted objective with a given sense (true = maximization).
def
TabuSearch( self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor):
1526 def TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor): 1527 r""" 1528 MetaHeuristics which try to get the search out of local optima. 1529 Creates a Tabu Search monitor. 1530 In the context of local search the behavior is similar to MakeOptimize(), 1531 creating an objective in a given sense. The behavior differs once a local 1532 optimum is reached: thereafter solutions which degrade the value of the 1533 objective are allowed if they are not "tabu". A solution is "tabu" if it 1534 doesn't respect the following rules: 1535 - improving the best solution found so far 1536 - variables in the "keep" list must keep their value, variables in the 1537 "forbid" list must not take the value they have in the list. 1538 Variables with new values enter the tabu lists after each new solution 1539 found and leave the lists after a given number of iterations (called 1540 tenure). Only the variables passed to the method can enter the lists. 1541 The tabu criterion is softened by the tabu factor which gives the number 1542 of "tabu" violations which is tolerated; a factor of 1 means no violations 1543 allowed; a factor of 0 means all violations are allowed. 1544 """ 1545 return _pywrapcp.Solver_TabuSearch(self, maximize, objective, step, vars, keep_tenure, forbid_tenure, tabu_factor)
MetaHeuristics which try to get the search out of local optima. Creates a Tabu Search monitor. In the context of local search the behavior is similar to MakeOptimize(), creating an objective in a given sense. The behavior differs once a local optimum is reached: thereafter solutions which degrade the value of the objective are allowed if they are not "tabu". A solution is "tabu" if it doesn't respect the following rules:
- improving the best solution found so far
- variables in the "keep" list must keep their value, variables in the "forbid" list must not take the value they have in the list. Variables with new values enter the tabu lists after each new solution found and leave the lists after a given number of iterations (called tenure). Only the variables passed to the method can enter the lists. The tabu criterion is softened by the tabu factor which gives the number of "tabu" violations which is tolerated; a factor of 1 means no violations allowed; a factor of 0 means all violations are allowed.
def
SimulatedAnnealing(self, maximize, v, step, initial_temperature):
1547 def SimulatedAnnealing(self, maximize, v, step, initial_temperature): 1548 r""" Creates a Simulated Annealing monitor.""" 1549 return _pywrapcp.Solver_SimulatedAnnealing(self, maximize, v, step, initial_temperature)
Creates a Simulated Annealing monitor.
def
LubyRestart(self, scale_factor):
1551 def LubyRestart(self, scale_factor): 1552 r""" 1553 This search monitor will restart the search periodically. 1554 At the iteration n, it will restart after scale_factor * Luby(n) failures 1555 where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...). 1556 """ 1557 return _pywrapcp.Solver_LubyRestart(self, scale_factor)
This search monitor will restart the search periodically. At the iteration n, it will restart after scale_factor * Luby(n) failures where Luby is the Luby Strategy (i.e. 1 1 2 1 1 2 4 1 1 2 1 1 2 4 8...).
def
ConstantRestart(self, frequency):
1559 def ConstantRestart(self, frequency): 1560 r""" 1561 This search monitor will restart the search periodically after 'frequency' 1562 failures. 1563 """ 1564 return _pywrapcp.Solver_ConstantRestart(self, frequency)
This search monitor will restart the search periodically after 'frequency' failures.
def
BranchesLimit(self, branches):
1569 def BranchesLimit(self, branches): 1570 r""" 1571 Creates a search limit that constrains the number of branches 1572 explored in the search tree. 1573 """ 1574 return _pywrapcp.Solver_BranchesLimit(self, branches)
Creates a search limit that constrains the number of branches explored in the search tree.
def
FailuresLimit(self, failures):
1576 def FailuresLimit(self, failures): 1577 r""" 1578 Creates a search limit that constrains the number of failures 1579 that can happen when exploring the search tree. 1580 """ 1581 return _pywrapcp.Solver_FailuresLimit(self, failures)
Creates a search limit that constrains the number of failures that can happen when exploring the search tree.
def
SolutionsLimit(self, solutions):
1583 def SolutionsLimit(self, solutions): 1584 r""" 1585 Creates a search limit that constrains the number of solutions found 1586 during the search. 1587 """ 1588 return _pywrapcp.Solver_SolutionsLimit(self, solutions)
Creates a search limit that constrains the number of solutions found during the search.
def
Limit(self, *args):
1590 def Limit(self, *args): 1591 r""" 1592 *Overload 1:* 1593 Limits the search with the 'time', 'branches', 'failures' and 1594 'solutions' limits. 'smart_time_check' reduces the calls to the wall 1595 1596 | 1597 1598 *Overload 2:* 1599 Creates a search limit from its protobuf description 1600 1601 | 1602 1603 *Overload 3:* 1604 Creates a search limit that is reached when either of the underlying limit 1605 is reached. That is, the returned limit is more stringent than both 1606 argument limits. 1607 """ 1608 return _pywrapcp.Solver_Limit(self, *args)
Overload 1: Limits the search with the 'time', 'branches', 'failures' and 'solutions' limits. 'smart_time_check' reduces the calls to the wall
|
Overload 2: Creates a search limit from its protobuf description
|
Overload 3: Creates a search limit that is reached when either of the underlying limit is reached. That is, the returned limit is more stringent than both argument limits.
def
CustomLimit(self, limiter):
1610 def CustomLimit(self, limiter): 1611 r""" 1612 Callback-based search limit. Search stops when limiter returns true; if 1613 this happens at a leaf the corresponding solution will be rejected. 1614 """ 1615 return _pywrapcp.Solver_CustomLimit(self, limiter)
Callback-based search limit. Search stops when limiter returns true; if this happens at a leaf the corresponding solution will be rejected.
def
SearchTrace(self, prefix):
1620 def SearchTrace(self, prefix): 1621 r""" 1622 Creates a search monitor that will trace precisely the behavior of the 1623 search. Use this only for low level debugging. 1624 """ 1625 return _pywrapcp.Solver_SearchTrace(self, prefix)
Creates a search monitor that will trace precisely the behavior of the search. Use this only for low level debugging.
def
PrintModelVisitor(self):
1627 def PrintModelVisitor(self): 1628 r""" Prints the model.""" 1629 return _pywrapcp.Solver_PrintModelVisitor(self)
Prints the model.
def
StatisticsModelVisitor(self):
1631 def StatisticsModelVisitor(self): 1632 r""" Displays some nice statistics on the model.""" 1633 return _pywrapcp.Solver_StatisticsModelVisitor(self)
Displays some nice statistics on the model.
def
AssignVariableValue(self, var, val):
1635 def AssignVariableValue(self, var, val): 1636 r""" Decisions.""" 1637 return _pywrapcp.Solver_AssignVariableValue(self, var, val)
Decisions.
def
ScheduleOrPostpone(self, var, est, marker):
1669 def ScheduleOrPostpone(self, var, est, marker): 1670 r""" 1671 Returns a decision that tries to schedule a task at a given time. 1672 On the Apply branch, it will set that interval var as performed and set 1673 its start to 'est'. On the Refute branch, it will just update the 1674 'marker' to 'est' + 1. This decision is used in the 1675 INTERVAL_SET_TIMES_FORWARD strategy. 1676 """ 1677 return _pywrapcp.Solver_ScheduleOrPostpone(self, var, est, marker)
Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its start to 'est'. On the Refute branch, it will just update the 'marker' to 'est' + 1. This decision is used in the INTERVAL_SET_TIMES_FORWARD strategy.
def
ScheduleOrExpedite(self, var, est, marker):
1679 def ScheduleOrExpedite(self, var, est, marker): 1680 r""" 1681 Returns a decision that tries to schedule a task at a given time. 1682 On the Apply branch, it will set that interval var as performed and set 1683 its end to 'est'. On the Refute branch, it will just update the 1684 'marker' to 'est' - 1. This decision is used in the 1685 INTERVAL_SET_TIMES_BACKWARD strategy. 1686 """ 1687 return _pywrapcp.Solver_ScheduleOrExpedite(self, var, est, marker)
Returns a decision that tries to schedule a task at a given time. On the Apply branch, it will set that interval var as performed and set its end to 'est'. On the Refute branch, it will just update the 'marker' to 'est' - 1. This decision is used in the INTERVAL_SET_TIMES_BACKWARD strategy.
def
RankFirstInterval(self, sequence, index):
1689 def RankFirstInterval(self, sequence, index): 1690 r""" 1691 Returns a decision that tries to rank first the ith interval var 1692 in the sequence variable. 1693 """ 1694 return _pywrapcp.Solver_RankFirstInterval(self, sequence, index)
Returns a decision that tries to rank first the ith interval var in the sequence variable.
def
RankLastInterval(self, sequence, index):
1696 def RankLastInterval(self, sequence, index): 1697 r""" 1698 Returns a decision that tries to rank last the ith interval var 1699 in the sequence variable. 1700 """ 1701 return _pywrapcp.Solver_RankLastInterval(self, sequence, index)
Returns a decision that tries to rank last the ith interval var in the sequence variable.
def
DecisionBuilderFromAssignment(self, assignment, db, vars):
1706 def DecisionBuilderFromAssignment(self, assignment, db, vars): 1707 r""" 1708 Returns a decision builder for which the left-most leaf corresponds 1709 to assignment, the rest of the tree being explored using 'db'. 1710 """ 1711 return _pywrapcp.Solver_DecisionBuilderFromAssignment(self, assignment, db, vars)
Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'.
def
ConstraintAdder(self, ct):
1713 def ConstraintAdder(self, ct): 1714 r""" 1715 Returns a decision builder that will add the given constraint to 1716 the model. 1717 """ 1718 return _pywrapcp.Solver_ConstraintAdder(self, ct)
Returns a decision builder that will add the given constraint to the model.
def
RestoreAssignment(self, assignment):
1726 def RestoreAssignment(self, assignment): 1727 r""" 1728 Returns a DecisionBuilder which restores an Assignment 1729 (calls void Assignment::Restore()) 1730 """ 1731 return _pywrapcp.Solver_RestoreAssignment(self, assignment)
Returns a DecisionBuilder which restores an Assignment (calls void Assignment::Restore())
def
StoreAssignment(self, assignment):
1733 def StoreAssignment(self, assignment): 1734 r""" 1735 Returns a DecisionBuilder which stores an Assignment 1736 (calls void Assignment::Store()) 1737 """ 1738 return _pywrapcp.Solver_StoreAssignment(self, assignment)
Returns a DecisionBuilder which stores an Assignment (calls void Assignment::Store())
def
MoveTowardTargetOperator(self, *args):
1746 def MoveTowardTargetOperator(self, *args): 1747 r""" 1748 *Overload 1:* 1749 Creates a local search operator that tries to move the assignment of some 1750 variables toward a target. The target is given as an Assignment. This 1751 operator generates neighbors in which the only difference compared to the 1752 current state is that one variable that belongs to the target assignment 1753 is set to its target value. 1754 1755 | 1756 1757 *Overload 2:* 1758 Creates a local search operator that tries to move the assignment of some 1759 variables toward a target. The target is given either as two vectors: a 1760 vector of variables and a vector of associated target values. The two 1761 vectors should be of the same length. This operator generates neighbors in 1762 which the only difference compared to the current state is that one 1763 variable that belongs to the given vector is set to its target value. 1764 """ 1765 return _pywrapcp.Solver_MoveTowardTargetOperator(self, *args)
Overload 1: Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given as an Assignment. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the target assignment is set to its target value.
|
Overload 2: Creates a local search operator that tries to move the assignment of some variables toward a target. The target is given either as two vectors: a vector of variables and a vector of associated target values. The two vectors should be of the same length. This operator generates neighbors in which the only difference compared to the current state is that one variable that belongs to the given vector is set to its target value.
def
RandomConcatenateOperators(self, *args):
1770 def RandomConcatenateOperators(self, *args): 1771 r""" 1772 *Overload 1:* 1773 Randomized version of local search concatenator; calls a random operator 1774 at each call to MakeNextNeighbor(). 1775 1776 | 1777 1778 *Overload 2:* 1779 Randomized version of local search concatenator; calls a random operator 1780 at each call to MakeNextNeighbor(). The provided seed is used to 1781 initialize the random number generator. 1782 """ 1783 return _pywrapcp.Solver_RandomConcatenateOperators(self, *args)
Overload 1: Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor().
|
Overload 2: Randomized version of local search concatenator; calls a random operator at each call to MakeNextNeighbor(). The provided seed is used to initialize the random number generator.
def
NeighborhoodLimit(self, op, limit):
1785 def NeighborhoodLimit(self, op, limit): 1786 r""" 1787 Creates a local search operator that wraps another local search 1788 operator and limits the number of neighbors explored (i.e., calls 1789 to MakeNextNeighbor from the current solution (between two calls 1790 to Start()). When this limit is reached, MakeNextNeighbor() 1791 returns false. The counter is cleared when Start() is called. 1792 """ 1793 return _pywrapcp.Solver_NeighborhoodLimit(self, op, limit)
Creates a local search operator that wraps another local search operator and limits the number of neighbors explored (i.e., calls to MakeNextNeighbor from the current solution (between two calls to Start()). When this limit is reached, MakeNextNeighbor() returns false. The counter is cleared when Start() is called.
def
TopProgressPercent(self):
1801 def TopProgressPercent(self): 1802 r""" 1803 Returns a percentage representing the propress of the search before 1804 reaching the limits of the top-level search (can be called from a nested 1805 solve). 1806 """ 1807 return _pywrapcp.Solver_TopProgressPercent(self)
Returns a percentage representing the propress of the search before reaching the limits of the top-level search (can be called from a nested solve).
def
SearchDepth(self):
1809 def SearchDepth(self): 1810 r""" 1811 Gets the search depth of the current active search. Returns -1 if 1812 there is no active search opened. 1813 """ 1814 return _pywrapcp.Solver_SearchDepth(self)
Gets the search depth of the current active search. Returns -1 if there is no active search opened.
def
SearchLeftDepth(self):
1816 def SearchLeftDepth(self): 1817 r""" 1818 Gets the search left depth of the current active search. Returns -1 if 1819 there is no active search opened. 1820 """ 1821 return _pywrapcp.Solver_SearchLeftDepth(self)
Gets the search left depth of the current active search. Returns -1 if there is no active search opened.
def
SolveDepth(self):
1823 def SolveDepth(self): 1824 r""" 1825 Gets the number of nested searches. It returns 0 outside search, 1826 1 during the top level search, 2 or more in case of nested searches. 1827 """ 1828 return _pywrapcp.Solver_SolveDepth(self)
Gets the number of nested searches. It returns 0 outside search, 1 during the top level search, 2 or more in case of nested searches.
def
Rand64(self, size):
1830 def Rand64(self, size): 1831 r""" Returns a random value between 0 and 'size' - 1;""" 1832 return _pywrapcp.Solver_Rand64(self, size)
Returns a random value between 0 and 'size' - 1;
def
Rand32(self, size):
1834 def Rand32(self, size): 1835 r""" Returns a random value between 0 and 'size' - 1;""" 1836 return _pywrapcp.Solver_Rand32(self, size)
Returns a random value between 0 and 'size' - 1;
def
ReSeed(self, seed):
1838 def ReSeed(self, seed): 1839 r""" Reseed the solver random generator.""" 1840 return _pywrapcp.Solver_ReSeed(self, seed)
Reseed the solver random generator.
def
LocalSearchProfile(self):
1842 def LocalSearchProfile(self): 1843 r""" Returns local search profiling information in a human readable format.""" 1844 return _pywrapcp.Solver_LocalSearchProfile(self)
Returns local search profiling information in a human readable format.
def
Constraints(self):
1846 def Constraints(self): 1847 r""" 1848 Counts the number of constraints that have been added 1849 to the solver before the search. 1850 """ 1851 return _pywrapcp.Solver_Constraints(self)
Counts the number of constraints that have been added to the solver before the search.
def
Accept(self, visitor):
1853 def Accept(self, visitor): 1854 r""" Accepts the given model visitor.""" 1855 return _pywrapcp.Solver_Accept(self, visitor)
Accepts the given model visitor.
def
FinishCurrentSearch(self):
1857 def FinishCurrentSearch(self): 1858 r""" Tells the solver to kill or restart the current search.""" 1859 return _pywrapcp.Solver_FinishCurrentSearch(self)
Tells the solver to kill or restart the current search.
def
ShouldFail(self):
1864 def ShouldFail(self): 1865 r""" 1866 These methods are only useful for the SWIG wrappers, which need a way 1867 to externally cause the Solver to fail. 1868 """ 1869 return _pywrapcp.Solver_ShouldFail(self)
These methods are only useful for the SWIG wrappers, which need a way to externally cause the Solver to fail.
class
BaseObject:
1918class BaseObject(object): 1919 r""" 1920 A BaseObject is the root of all reversibly allocated objects. 1921 A DebugString method and the associated << operator are implemented 1922 as a convenience. 1923 """ 1924 1925 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1926 1927 def __init__(self): 1928 if self.__class__ == BaseObject: 1929 _self = None 1930 else: 1931 _self = self 1932 _pywrapcp.BaseObject_swiginit(self, _pywrapcp.new_BaseObject(_self, )) 1933 __swig_destroy__ = _pywrapcp.delete_BaseObject 1934 1935 def DebugString(self): 1936 return _pywrapcp.BaseObject_DebugString(self) 1937 1938 def __str__(self): 1939 return _pywrapcp.BaseObject___str__(self) 1940 1941 def __repr__(self): 1942 return _pywrapcp.BaseObject___repr__(self) 1943 def __disown__(self): 1944 self.this.disown() 1945 _pywrapcp.disown_BaseObject(self) 1946 return weakref.proxy(self)
A BaseObject is the root of all reversibly allocated objects. A DebugString method and the associated << operator are implemented as a convenience.
1950class PropagationBaseObject(BaseObject): 1951 r""" 1952 NOLINT 1953 The PropagationBaseObject is a subclass of BaseObject that is also 1954 friend to the Solver class. It allows accessing methods useful when 1955 writing new constraints or new expressions. 1956 """ 1957 1958 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1959 __repr__ = _swig_repr 1960 1961 def __init__(self, s): 1962 if self.__class__ == PropagationBaseObject: 1963 _self = None 1964 else: 1965 _self = self 1966 _pywrapcp.PropagationBaseObject_swiginit(self, _pywrapcp.new_PropagationBaseObject(_self, s)) 1967 __swig_destroy__ = _pywrapcp.delete_PropagationBaseObject 1968 1969 def DebugString(self): 1970 return _pywrapcp.PropagationBaseObject_DebugString(self) 1971 1972 def solver(self): 1973 return _pywrapcp.PropagationBaseObject_solver(self) 1974 1975 def Name(self): 1976 r""" Object naming.""" 1977 return _pywrapcp.PropagationBaseObject_Name(self) 1978 def __disown__(self): 1979 self.this.disown() 1980 _pywrapcp.disown_PropagationBaseObject(self) 1981 return weakref.proxy(self)
NOLINT The PropagationBaseObject is a subclass of BaseObject that is also friend to the Solver class. It allows accessing methods useful when writing new constraints or new expressions.
1985class Decision(BaseObject): 1986 r""" 1987 A Decision represents a choice point in the search tree. The two main 1988 methods are Apply() to go left, or Refute() to go right. 1989 """ 1990 1991 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 1992 1993 def __init__(self): 1994 if self.__class__ == Decision: 1995 _self = None 1996 else: 1997 _self = self 1998 _pywrapcp.Decision_swiginit(self, _pywrapcp.new_Decision(_self, )) 1999 __swig_destroy__ = _pywrapcp.delete_Decision 2000 2001 def ApplyWrapper(self, s): 2002 r""" Apply will be called first when the decision is executed.""" 2003 return _pywrapcp.Decision_ApplyWrapper(self, s) 2004 2005 def RefuteWrapper(self, s): 2006 r""" Refute will be called after a backtrack.""" 2007 return _pywrapcp.Decision_RefuteWrapper(self, s) 2008 2009 def DebugString(self): 2010 return _pywrapcp.Decision_DebugString(self) 2011 2012 def __repr__(self): 2013 return _pywrapcp.Decision___repr__(self) 2014 2015 def __str__(self): 2016 return _pywrapcp.Decision___str__(self) 2017 def __disown__(self): 2018 self.this.disown() 2019 _pywrapcp.disown_Decision(self) 2020 return weakref.proxy(self)
A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right.
def
ApplyWrapper(self, s):
2001 def ApplyWrapper(self, s): 2002 r""" Apply will be called first when the decision is executed.""" 2003 return _pywrapcp.Decision_ApplyWrapper(self, s)
Apply will be called first when the decision is executed.
2024class DecisionBuilder(BaseObject): 2025 r""" 2026 A DecisionBuilder is responsible for creating the search tree. The 2027 important method is Next(), which returns the next decision to execute. 2028 """ 2029 2030 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2031 2032 def __init__(self): 2033 if self.__class__ == DecisionBuilder: 2034 _self = None 2035 else: 2036 _self = self 2037 _pywrapcp.DecisionBuilder_swiginit(self, _pywrapcp.new_DecisionBuilder(_self, )) 2038 __swig_destroy__ = _pywrapcp.delete_DecisionBuilder 2039 2040 def NextWrapper(self, s): 2041 r""" 2042 This is the main method of the decision builder class. It must 2043 return a decision (an instance of the class Decision). If it 2044 returns nullptr, this means that the decision builder has finished 2045 its work. 2046 """ 2047 return _pywrapcp.DecisionBuilder_NextWrapper(self, s) 2048 2049 def DebugString(self): 2050 return _pywrapcp.DecisionBuilder_DebugString(self) 2051 2052 def __repr__(self): 2053 return _pywrapcp.DecisionBuilder___repr__(self) 2054 2055 def __str__(self): 2056 return _pywrapcp.DecisionBuilder___str__(self) 2057 def __disown__(self): 2058 self.this.disown() 2059 _pywrapcp.disown_DecisionBuilder(self) 2060 return weakref.proxy(self)
A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.
def
NextWrapper(self, s):
2040 def NextWrapper(self, s): 2041 r""" 2042 This is the main method of the decision builder class. It must 2043 return a decision (an instance of the class Decision). If it 2044 returns nullptr, this means that the decision builder has finished 2045 its work. 2046 """ 2047 return _pywrapcp.DecisionBuilder_NextWrapper(self, s)
This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work.
2064class Demon(BaseObject): 2065 r""" 2066 A Demon is the base element of a propagation queue. It is the main 2067 object responsible for implementing the actual propagation 2068 of the constraint and pruning the inconsistent values in the domains 2069 of the variables. The main concept is that demons are listeners that are 2070 attached to the variables and listen to their modifications. 2071 There are two methods: 2072 - Run() is the actual method called when the demon is processed. 2073 - priority() returns its priority. Standard priorities are slow, normal 2074 or fast. "immediate" is reserved for variables and is treated separately. 2075 """ 2076 2077 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2078 __repr__ = _swig_repr 2079 2080 def __init__(self): 2081 r""" 2082 This indicates the priority of a demon. Immediate demons are treated 2083 separately and corresponds to variables. 2084 """ 2085 if self.__class__ == Demon: 2086 _self = None 2087 else: 2088 _self = self 2089 _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, )) 2090 __swig_destroy__ = _pywrapcp.delete_Demon 2091 2092 def RunWrapper(self, s): 2093 r""" This is the main callback of the demon.""" 2094 return _pywrapcp.Demon_RunWrapper(self, s) 2095 2096 def Priority(self): 2097 r""" 2098 This method returns the priority of the demon. Usually a demon is 2099 fast, slow or normal. Immediate demons are reserved for internal 2100 use to maintain variables. 2101 """ 2102 return _pywrapcp.Demon_Priority(self) 2103 2104 def DebugString(self): 2105 return _pywrapcp.Demon_DebugString(self) 2106 2107 def Inhibit(self, s): 2108 r""" 2109 This method inhibits the demon in the search tree below the 2110 current position. 2111 """ 2112 return _pywrapcp.Demon_Inhibit(self, s) 2113 2114 def Desinhibit(self, s): 2115 r""" This method un-inhibits the demon that was previously inhibited.""" 2116 return _pywrapcp.Demon_Desinhibit(self, s) 2117 def __disown__(self): 2118 self.this.disown() 2119 _pywrapcp.disown_Demon(self) 2120 return weakref.proxy(self)
A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications.
There are two methods:
- Run() is the actual method called when the demon is processed.
- priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately.
Demon()
2080 def __init__(self): 2081 r""" 2082 This indicates the priority of a demon. Immediate demons are treated 2083 separately and corresponds to variables. 2084 """ 2085 if self.__class__ == Demon: 2086 _self = None 2087 else: 2088 _self = self 2089 _pywrapcp.Demon_swiginit(self, _pywrapcp.new_Demon(_self, ))
This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.
def
RunWrapper(self, s):
2092 def RunWrapper(self, s): 2093 r""" This is the main callback of the demon.""" 2094 return _pywrapcp.Demon_RunWrapper(self, s)
This is the main callback of the demon.
def
Priority(self):
2096 def Priority(self): 2097 r""" 2098 This method returns the priority of the demon. Usually a demon is 2099 fast, slow or normal. Immediate demons are reserved for internal 2100 use to maintain variables. 2101 """ 2102 return _pywrapcp.Demon_Priority(self)
This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables.
2124class Constraint(PropagationBaseObject): 2125 r""" 2126 A constraint is the main modeling object. It provides two methods: 2127 - Post() is responsible for creating the demons and attaching them to 2128 immediate demons(). 2129 - InitialPropagate() is called once just after Post and performs 2130 the initial propagation. The subsequent propagations will be performed 2131 by the demons Posted during the post() method. 2132 """ 2133 2134 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2135 2136 def __init__(self, solver): 2137 if self.__class__ == Constraint: 2138 _self = None 2139 else: 2140 _self = self 2141 _pywrapcp.Constraint_swiginit(self, _pywrapcp.new_Constraint(_self, solver)) 2142 __swig_destroy__ = _pywrapcp.delete_Constraint 2143 2144 def Post(self): 2145 r""" 2146 This method is called when the constraint is processed by the 2147 solver. Its main usage is to attach demons to variables. 2148 """ 2149 return _pywrapcp.Constraint_Post(self) 2150 2151 def InitialPropagateWrapper(self): 2152 r""" 2153 This method performs the initial propagation of the 2154 constraint. It is called just after the post. 2155 """ 2156 return _pywrapcp.Constraint_InitialPropagateWrapper(self) 2157 2158 def DebugString(self): 2159 return _pywrapcp.Constraint_DebugString(self) 2160 2161 def Var(self): 2162 r""" 2163 Creates a Boolean variable representing the status of the constraint 2164 (false = constraint is violated, true = constraint is satisfied). It 2165 returns nullptr if the constraint does not support this API. 2166 """ 2167 return _pywrapcp.Constraint_Var(self) 2168 2169 def __repr__(self): 2170 return _pywrapcp.Constraint___repr__(self) 2171 2172 def __str__(self): 2173 return _pywrapcp.Constraint___str__(self) 2174 2175 def __add__(self, *args): 2176 return _pywrapcp.Constraint___add__(self, *args) 2177 2178 def __radd__(self, v): 2179 return _pywrapcp.Constraint___radd__(self, v) 2180 2181 def __sub__(self, *args): 2182 return _pywrapcp.Constraint___sub__(self, *args) 2183 2184 def __rsub__(self, v): 2185 return _pywrapcp.Constraint___rsub__(self, v) 2186 2187 def __mul__(self, *args): 2188 return _pywrapcp.Constraint___mul__(self, *args) 2189 2190 def __rmul__(self, v): 2191 return _pywrapcp.Constraint___rmul__(self, v) 2192 2193 def __floordiv__(self, v): 2194 return _pywrapcp.Constraint___floordiv__(self, v) 2195 2196 def __neg__(self): 2197 return _pywrapcp.Constraint___neg__(self) 2198 2199 def __abs__(self): 2200 return _pywrapcp.Constraint___abs__(self) 2201 2202 def Square(self): 2203 return _pywrapcp.Constraint_Square(self) 2204 2205 def __eq__(self, *args): 2206 return _pywrapcp.Constraint___eq__(self, *args) 2207 2208 def __ne__(self, *args): 2209 return _pywrapcp.Constraint___ne__(self, *args) 2210 2211 def __ge__(self, *args): 2212 return _pywrapcp.Constraint___ge__(self, *args) 2213 2214 def __gt__(self, *args): 2215 return _pywrapcp.Constraint___gt__(self, *args) 2216 2217 def __le__(self, *args): 2218 return _pywrapcp.Constraint___le__(self, *args) 2219 2220 def __lt__(self, *args): 2221 return _pywrapcp.Constraint___lt__(self, *args) 2222 2223 def MapTo(self, vars): 2224 return _pywrapcp.Constraint_MapTo(self, vars) 2225 2226 def IndexOf(self, *args): 2227 return _pywrapcp.Constraint_IndexOf(self, *args) 2228 def __disown__(self): 2229 self.this.disown() 2230 _pywrapcp.disown_Constraint(self) 2231 return weakref.proxy(self)
A constraint is the main modeling object. It provides two methods:
- Post() is responsible for creating the demons and attaching them to immediate demons().
- InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
def
Post(self):
2144 def Post(self): 2145 r""" 2146 This method is called when the constraint is processed by the 2147 solver. Its main usage is to attach demons to variables. 2148 """ 2149 return _pywrapcp.Constraint_Post(self)
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
2151 def InitialPropagateWrapper(self): 2152 r""" 2153 This method performs the initial propagation of the 2154 constraint. It is called just after the post. 2155 """ 2156 return _pywrapcp.Constraint_InitialPropagateWrapper(self)
This method performs the initial propagation of the constraint. It is called just after the post.
def
Var(self):
2161 def Var(self): 2162 r""" 2163 Creates a Boolean variable representing the status of the constraint 2164 (false = constraint is violated, true = constraint is satisfied). It 2165 returns nullptr if the constraint does not support this API. 2166 """ 2167 return _pywrapcp.Constraint_Var(self)
Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied). It returns nullptr if the constraint does not support this API.
Inherited Members
2235class SearchMonitor(BaseObject): 2236 r""" A search monitor is a simple set of callbacks to monitor all search events""" 2237 2238 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2239 kNoProgress = _pywrapcp.SearchMonitor_kNoProgress 2240 2241 def __init__(self, s): 2242 if self.__class__ == SearchMonitor: 2243 _self = None 2244 else: 2245 _self = self 2246 _pywrapcp.SearchMonitor_swiginit(self, _pywrapcp.new_SearchMonitor(_self, s)) 2247 __swig_destroy__ = _pywrapcp.delete_SearchMonitor 2248 2249 def EnterSearch(self): 2250 r""" Beginning of the search.""" 2251 return _pywrapcp.SearchMonitor_EnterSearch(self) 2252 2253 def RestartSearch(self): 2254 r""" Restart the search.""" 2255 return _pywrapcp.SearchMonitor_RestartSearch(self) 2256 2257 def ExitSearch(self): 2258 r""" End of the search.""" 2259 return _pywrapcp.SearchMonitor_ExitSearch(self) 2260 2261 def BeginNextDecision(self, b): 2262 r""" Before calling DecisionBuilder::Next.""" 2263 return _pywrapcp.SearchMonitor_BeginNextDecision(self, b) 2264 2265 def EndNextDecision(self, b, d): 2266 r""" After calling DecisionBuilder::Next, along with the returned decision.""" 2267 return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d) 2268 2269 def ApplyDecision(self, d): 2270 r""" Before applying the decision.""" 2271 return _pywrapcp.SearchMonitor_ApplyDecision(self, d) 2272 2273 def RefuteDecision(self, d): 2274 r""" Before refuting the decision.""" 2275 return _pywrapcp.SearchMonitor_RefuteDecision(self, d) 2276 2277 def AfterDecision(self, d, apply): 2278 r""" 2279 Just after refuting or applying the decision, apply is true after Apply. 2280 This is called only if the Apply() or Refute() methods have not failed. 2281 """ 2282 return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply) 2283 2284 def BeginFail(self): 2285 r""" Just when the failure occurs.""" 2286 return _pywrapcp.SearchMonitor_BeginFail(self) 2287 2288 def EndFail(self): 2289 r""" After completing the backtrack.""" 2290 return _pywrapcp.SearchMonitor_EndFail(self) 2291 2292 def BeginInitialPropagation(self): 2293 r""" Before the initial propagation.""" 2294 return _pywrapcp.SearchMonitor_BeginInitialPropagation(self) 2295 2296 def EndInitialPropagation(self): 2297 r""" After the initial propagation.""" 2298 return _pywrapcp.SearchMonitor_EndInitialPropagation(self) 2299 2300 def AcceptSolution(self): 2301 r""" 2302 This method is called when a solution is found. It asserts whether the 2303 solution is valid. A value of false indicates that the solution 2304 should be discarded. 2305 """ 2306 return _pywrapcp.SearchMonitor_AcceptSolution(self) 2307 2308 def AtSolution(self): 2309 r""" 2310 This method is called when a valid solution is found. If the 2311 return value is true, then search will resume after. If the result 2312 is false, then search will stop there. 2313 """ 2314 return _pywrapcp.SearchMonitor_AtSolution(self) 2315 2316 def NoMoreSolutions(self): 2317 r""" When the search tree is finished.""" 2318 return _pywrapcp.SearchMonitor_NoMoreSolutions(self) 2319 2320 def LocalOptimum(self): 2321 r""" 2322 When a local optimum is reached. If 'true' is returned, the last solution 2323 is discarded and the search proceeds with the next one. 2324 """ 2325 return _pywrapcp.SearchMonitor_LocalOptimum(self) 2326 2327 def AcceptDelta(self, delta, deltadelta): 2328 2329 return _pywrapcp.SearchMonitor_AcceptDelta(self, delta, deltadelta) 2330 2331 def AcceptNeighbor(self): 2332 r""" After accepting a neighbor during local search.""" 2333 return _pywrapcp.SearchMonitor_AcceptNeighbor(self) 2334 2335 def ProgressPercent(self): 2336 r""" 2337 Returns a percentage representing the propress of the search before 2338 reaching limits. 2339 """ 2340 return _pywrapcp.SearchMonitor_ProgressPercent(self) 2341 2342 def solver(self): 2343 return _pywrapcp.SearchMonitor_solver(self) 2344 2345 def __repr__(self): 2346 return _pywrapcp.SearchMonitor___repr__(self) 2347 2348 def __str__(self): 2349 return _pywrapcp.SearchMonitor___str__(self) 2350 def __disown__(self): 2351 self.this.disown() 2352 _pywrapcp.disown_SearchMonitor(self) 2353 return weakref.proxy(self)
A search monitor is a simple set of callbacks to monitor all search events
def
EnterSearch(self):
2249 def EnterSearch(self): 2250 r""" Beginning of the search.""" 2251 return _pywrapcp.SearchMonitor_EnterSearch(self)
Beginning of the search.
def
RestartSearch(self):
2253 def RestartSearch(self): 2254 r""" Restart the search.""" 2255 return _pywrapcp.SearchMonitor_RestartSearch(self)
Restart the search.
def
ExitSearch(self):
2257 def ExitSearch(self): 2258 r""" End of the search.""" 2259 return _pywrapcp.SearchMonitor_ExitSearch(self)
End of the search.
def
BeginNextDecision(self, b):
2261 def BeginNextDecision(self, b): 2262 r""" Before calling DecisionBuilder::Next.""" 2263 return _pywrapcp.SearchMonitor_BeginNextDecision(self, b)
Before calling DecisionBuilder::Next.
def
EndNextDecision(self, b, d):
2265 def EndNextDecision(self, b, d): 2266 r""" After calling DecisionBuilder::Next, along with the returned decision.""" 2267 return _pywrapcp.SearchMonitor_EndNextDecision(self, b, d)
After calling DecisionBuilder::Next, along with the returned decision.
def
ApplyDecision(self, d):
2269 def ApplyDecision(self, d): 2270 r""" Before applying the decision.""" 2271 return _pywrapcp.SearchMonitor_ApplyDecision(self, d)
Before applying the decision.
def
RefuteDecision(self, d):
2273 def RefuteDecision(self, d): 2274 r""" Before refuting the decision.""" 2275 return _pywrapcp.SearchMonitor_RefuteDecision(self, d)
Before refuting the decision.
def
AfterDecision(self, d, apply):
2277 def AfterDecision(self, d, apply): 2278 r""" 2279 Just after refuting or applying the decision, apply is true after Apply. 2280 This is called only if the Apply() or Refute() methods have not failed. 2281 """ 2282 return _pywrapcp.SearchMonitor_AfterDecision(self, d, apply)
Just after refuting or applying the decision, apply is true after Apply. This is called only if the Apply() or Refute() methods have not failed.
def
BeginFail(self):
2284 def BeginFail(self): 2285 r""" Just when the failure occurs.""" 2286 return _pywrapcp.SearchMonitor_BeginFail(self)
Just when the failure occurs.
def
EndFail(self):
2288 def EndFail(self): 2289 r""" After completing the backtrack.""" 2290 return _pywrapcp.SearchMonitor_EndFail(self)
After completing the backtrack.
def
BeginInitialPropagation(self):
2292 def BeginInitialPropagation(self): 2293 r""" Before the initial propagation.""" 2294 return _pywrapcp.SearchMonitor_BeginInitialPropagation(self)
Before the initial propagation.
def
EndInitialPropagation(self):
2296 def EndInitialPropagation(self): 2297 r""" After the initial propagation.""" 2298 return _pywrapcp.SearchMonitor_EndInitialPropagation(self)
After the initial propagation.
def
AcceptSolution(self):
2300 def AcceptSolution(self): 2301 r""" 2302 This method is called when a solution is found. It asserts whether the 2303 solution is valid. A value of false indicates that the solution 2304 should be discarded. 2305 """ 2306 return _pywrapcp.SearchMonitor_AcceptSolution(self)
This method is called when a solution is found. It asserts whether the solution is valid. A value of false indicates that the solution should be discarded.
def
AtSolution(self):
2308 def AtSolution(self): 2309 r""" 2310 This method is called when a valid solution is found. If the 2311 return value is true, then search will resume after. If the result 2312 is false, then search will stop there. 2313 """ 2314 return _pywrapcp.SearchMonitor_AtSolution(self)
This method is called when a valid solution is found. If the return value is true, then search will resume after. If the result is false, then search will stop there.
def
NoMoreSolutions(self):
2316 def NoMoreSolutions(self): 2317 r""" When the search tree is finished.""" 2318 return _pywrapcp.SearchMonitor_NoMoreSolutions(self)
When the search tree is finished.
def
LocalOptimum(self):
2320 def LocalOptimum(self): 2321 r""" 2322 When a local optimum is reached. If 'true' is returned, the last solution 2323 is discarded and the search proceeds with the next one. 2324 """ 2325 return _pywrapcp.SearchMonitor_LocalOptimum(self)
When a local optimum is reached. If 'true' is returned, the last solution is discarded and the search proceeds with the next one.
def
AcceptNeighbor(self):
2331 def AcceptNeighbor(self): 2332 r""" After accepting a neighbor during local search.""" 2333 return _pywrapcp.SearchMonitor_AcceptNeighbor(self)
After accepting a neighbor during local search.
def
ProgressPercent(self):
2335 def ProgressPercent(self): 2336 r""" 2337 Returns a percentage representing the propress of the search before 2338 reaching limits. 2339 """ 2340 return _pywrapcp.SearchMonitor_ProgressPercent(self)
Returns a percentage representing the propress of the search before reaching limits.
Inherited Members
2357class IntExpr(PropagationBaseObject): 2358 r""" 2359 The class IntExpr is the base of all integer expressions in 2360 constraint programming. 2361 It contains the basic protocol for an expression: 2362 - setting and modifying its bound 2363 - querying if it is bound 2364 - listening to events modifying its bounds 2365 - casting it into a variable (instance of IntVar) 2366 """ 2367 2368 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2369 2370 def __init__(self, *args, **kwargs): 2371 raise AttributeError("No constructor defined - class is abstract") 2372 2373 def Min(self): 2374 return _pywrapcp.IntExpr_Min(self) 2375 2376 def SetMin(self, m): 2377 return _pywrapcp.IntExpr_SetMin(self, m) 2378 2379 def Max(self): 2380 return _pywrapcp.IntExpr_Max(self) 2381 2382 def SetMax(self, m): 2383 return _pywrapcp.IntExpr_SetMax(self, m) 2384 2385 def SetRange(self, l, u): 2386 r""" This method sets both the min and the max of the expression.""" 2387 return _pywrapcp.IntExpr_SetRange(self, l, u) 2388 2389 def SetValue(self, v): 2390 r""" This method sets the value of the expression.""" 2391 return _pywrapcp.IntExpr_SetValue(self, v) 2392 2393 def Bound(self): 2394 r""" Returns true if the min and the max of the expression are equal.""" 2395 return _pywrapcp.IntExpr_Bound(self) 2396 2397 def IsVar(self): 2398 r""" Returns true if the expression is indeed a variable.""" 2399 return _pywrapcp.IntExpr_IsVar(self) 2400 2401 def Var(self): 2402 r""" Creates a variable from the expression.""" 2403 return _pywrapcp.IntExpr_Var(self) 2404 2405 def VarWithName(self, name): 2406 r""" 2407 Creates a variable from the expression and set the name of the 2408 resulting var. If the expression is already a variable, then it 2409 will set the name of the expression, possibly overwriting it. 2410 This is just a shortcut to Var() followed by set_name(). 2411 """ 2412 return _pywrapcp.IntExpr_VarWithName(self, name) 2413 2414 def WhenRange(self, *args): 2415 r""" 2416 *Overload 1:* 2417 Attach a demon that will watch the min or the max of the expression. 2418 2419 | 2420 2421 *Overload 2:* 2422 Attach a demon that will watch the min or the max of the expression. 2423 """ 2424 return _pywrapcp.IntExpr_WhenRange(self, *args) 2425 2426 def __repr__(self): 2427 return _pywrapcp.IntExpr___repr__(self) 2428 2429 def __str__(self): 2430 return _pywrapcp.IntExpr___str__(self) 2431 2432 def __add__(self, *args): 2433 return _pywrapcp.IntExpr___add__(self, *args) 2434 2435 def __radd__(self, v): 2436 return _pywrapcp.IntExpr___radd__(self, v) 2437 2438 def __sub__(self, *args): 2439 return _pywrapcp.IntExpr___sub__(self, *args) 2440 2441 def __rsub__(self, v): 2442 return _pywrapcp.IntExpr___rsub__(self, v) 2443 2444 def __mul__(self, *args): 2445 return _pywrapcp.IntExpr___mul__(self, *args) 2446 2447 def __rmul__(self, v): 2448 return _pywrapcp.IntExpr___rmul__(self, v) 2449 2450 def __floordiv__(self, *args): 2451 return _pywrapcp.IntExpr___floordiv__(self, *args) 2452 2453 def __mod__(self, *args): 2454 return _pywrapcp.IntExpr___mod__(self, *args) 2455 2456 def __neg__(self): 2457 return _pywrapcp.IntExpr___neg__(self) 2458 2459 def __abs__(self): 2460 return _pywrapcp.IntExpr___abs__(self) 2461 2462 def Square(self): 2463 return _pywrapcp.IntExpr_Square(self) 2464 2465 def __eq__(self, *args): 2466 return _pywrapcp.IntExpr___eq__(self, *args) 2467 2468 def __ne__(self, *args): 2469 return _pywrapcp.IntExpr___ne__(self, *args) 2470 2471 def __ge__(self, *args): 2472 return _pywrapcp.IntExpr___ge__(self, *args) 2473 2474 def __gt__(self, *args): 2475 return _pywrapcp.IntExpr___gt__(self, *args) 2476 2477 def __le__(self, *args): 2478 return _pywrapcp.IntExpr___le__(self, *args) 2479 2480 def __lt__(self, *args): 2481 return _pywrapcp.IntExpr___lt__(self, *args) 2482 2483 def MapTo(self, vars): 2484 return _pywrapcp.IntExpr_MapTo(self, vars) 2485 2486 def IndexOf(self, *args): 2487 return _pywrapcp.IntExpr_IndexOf(self, *args) 2488 2489 def IsMember(self, values): 2490 return _pywrapcp.IntExpr_IsMember(self, values) 2491 2492 def Member(self, values): 2493 return _pywrapcp.IntExpr_Member(self, values) 2494 2495 def NotMember(self, starts, ends): 2496 return _pywrapcp.IntExpr_NotMember(self, starts, ends)
The class IntExpr is the base of all integer expressions in constraint programming.
It contains the basic protocol for an expression:
- setting and modifying its bound
- querying if it is bound
- listening to events modifying its bounds
- casting it into a variable (instance of IntVar)
def
SetRange(self, l, u):
2385 def SetRange(self, l, u): 2386 r""" This method sets both the min and the max of the expression.""" 2387 return _pywrapcp.IntExpr_SetRange(self, l, u)
This method sets both the min and the max of the expression.
def
SetValue(self, v):
2389 def SetValue(self, v): 2390 r""" This method sets the value of the expression.""" 2391 return _pywrapcp.IntExpr_SetValue(self, v)
This method sets the value of the expression.
def
Bound(self):
2393 def Bound(self): 2394 r""" Returns true if the min and the max of the expression are equal.""" 2395 return _pywrapcp.IntExpr_Bound(self)
Returns true if the min and the max of the expression are equal.
def
IsVar(self):
2397 def IsVar(self): 2398 r""" Returns true if the expression is indeed a variable.""" 2399 return _pywrapcp.IntExpr_IsVar(self)
Returns true if the expression is indeed a variable.
def
Var(self):
2401 def Var(self): 2402 r""" Creates a variable from the expression.""" 2403 return _pywrapcp.IntExpr_Var(self)
Creates a variable from the expression.
def
VarWithName(self, name):
2405 def VarWithName(self, name): 2406 r""" 2407 Creates a variable from the expression and set the name of the 2408 resulting var. If the expression is already a variable, then it 2409 will set the name of the expression, possibly overwriting it. 2410 This is just a shortcut to Var() followed by set_name(). 2411 """ 2412 return _pywrapcp.IntExpr_VarWithName(self, name)
Creates a variable from the expression and set the name of the resulting var. If the expression is already a variable, then it will set the name of the expression, possibly overwriting it. This is just a shortcut to Var() followed by set_name().
def
WhenRange(self, *args):
2414 def WhenRange(self, *args): 2415 r""" 2416 *Overload 1:* 2417 Attach a demon that will watch the min or the max of the expression. 2418 2419 | 2420 2421 *Overload 2:* 2422 Attach a demon that will watch the min or the max of the expression. 2423 """ 2424 return _pywrapcp.IntExpr_WhenRange(self, *args)
Overload 1: Attach a demon that will watch the min or the max of the expression.
|
Overload 2: Attach a demon that will watch the min or the max of the expression.
Inherited Members
2500class IntVarIterator(BaseObject): 2501 r""" 2502 The class Iterator has two direct subclasses. HoleIterators 2503 iterates over all holes, that is value removed between the 2504 current min and max of the variable since the last time the 2505 variable was processed in the queue. DomainIterators iterates 2506 over all elements of the variable domain. Both iterators are not 2507 robust to domain changes. Hole iterators can also report values outside 2508 the current min and max of the variable. 2509 HoleIterators should only be called from a demon attached to the 2510 variable that has created this iterator. 2511 IntVar* current_var; 2512 std::unique_ptr<IntVarIterator> it(current_var->MakeHoleIterator(false)); 2513 for (const int64_t hole : InitAndGetValues(it)) { 2514 use the hole 2515 } 2516 """ 2517 2518 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2519 2520 def __init__(self, *args, **kwargs): 2521 raise AttributeError("No constructor defined - class is abstract") 2522 __repr__ = _swig_repr 2523 2524 def Init(self): 2525 r""" This method must be called before each loop.""" 2526 return _pywrapcp.IntVarIterator_Init(self) 2527 2528 def Ok(self): 2529 r""" This method indicates if we can call Value() or not.""" 2530 return _pywrapcp.IntVarIterator_Ok(self) 2531 2532 def Value(self): 2533 r""" This method returns the current value of the iterator.""" 2534 return _pywrapcp.IntVarIterator_Value(self) 2535 2536 def Next(self): 2537 r""" This method moves the iterator to the next value.""" 2538 return _pywrapcp.IntVarIterator_Next(self) 2539 2540 def DebugString(self): 2541 r""" Pretty Print.""" 2542 return _pywrapcp.IntVarIterator_DebugString(self) 2543 2544 def __iter__(self): 2545 self.Init() 2546 return self 2547 2548 def next(self): 2549 if self.Ok(): 2550 result = self.Value() 2551 self.Next() 2552 return result 2553 else: 2554 raise StopIteration() 2555 2556 def __next__(self): 2557 return self.next()
The class Iterator has two direct subclasses. HoleIterators
iterates over all holes, that is value removed between the
current min and max of the variable since the last time the
variable was processed in the queue. DomainIterators iterates
over all elements of the variable domain. Both iterators are not
robust to domain changes. Hole iterators can also report values outside
the current min and max of the variable.
HoleIterators should only be called from a demon attached to the
variable that has created this iterator.
IntVar* current_var;
std::unique_ptr
def
Init(self):
2524 def Init(self): 2525 r""" This method must be called before each loop.""" 2526 return _pywrapcp.IntVarIterator_Init(self)
This method must be called before each loop.
def
Ok(self):
2528 def Ok(self): 2529 r""" This method indicates if we can call Value() or not.""" 2530 return _pywrapcp.IntVarIterator_Ok(self)
This method indicates if we can call Value() or not.
def
Value(self):
2532 def Value(self): 2533 r""" This method returns the current value of the iterator.""" 2534 return _pywrapcp.IntVarIterator_Value(self)
This method returns the current value of the iterator.
def
Next(self):
2536 def Next(self): 2537 r""" This method moves the iterator to the next value.""" 2538 return _pywrapcp.IntVarIterator_Next(self)
This method moves the iterator to the next value.
2562class IntVar(IntExpr): 2563 r""" 2564 The class IntVar is a subset of IntExpr. In addition to the 2565 IntExpr protocol, it offers persistence, removing values from the domains, 2566 and a finer model for events. 2567 """ 2568 2569 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2570 2571 def __init__(self, *args, **kwargs): 2572 raise AttributeError("No constructor defined - class is abstract") 2573 2574 def IsVar(self): 2575 return _pywrapcp.IntVar_IsVar(self) 2576 2577 def Var(self): 2578 return _pywrapcp.IntVar_Var(self) 2579 2580 def Value(self): 2581 r""" 2582 This method returns the value of the variable. This method checks 2583 before that the variable is bound. 2584 """ 2585 return _pywrapcp.IntVar_Value(self) 2586 2587 def RemoveValue(self, v): 2588 r""" This method removes the value 'v' from the domain of the variable.""" 2589 return _pywrapcp.IntVar_RemoveValue(self, v) 2590 2591 def RemoveInterval(self, l, u): 2592 r""" 2593 This method removes the interval 'l' .. 'u' from the domain of 2594 the variable. It assumes that 'l' <= 'u'. 2595 """ 2596 return _pywrapcp.IntVar_RemoveInterval(self, l, u) 2597 2598 def RemoveValues(self, values): 2599 r""" This method remove the values from the domain of the variable.""" 2600 return _pywrapcp.IntVar_RemoveValues(self, values) 2601 2602 def SetValues(self, values): 2603 r""" This method intersects the current domain with the values in the array.""" 2604 return _pywrapcp.IntVar_SetValues(self, values) 2605 2606 def WhenBound(self, *args): 2607 r""" 2608 *Overload 1:* 2609 This method attaches a demon that will be awakened when the 2610 variable is bound. 2611 2612 | 2613 2614 *Overload 2:* 2615 This method attaches a closure that will be awakened when the 2616 variable is bound. 2617 """ 2618 return _pywrapcp.IntVar_WhenBound(self, *args) 2619 2620 def WhenDomain(self, *args): 2621 r""" 2622 *Overload 1:* 2623 This method attaches a demon that will watch any domain 2624 modification of the domain of the variable. 2625 2626 | 2627 2628 *Overload 2:* 2629 This method attaches a closure that will watch any domain 2630 modification of the domain of the variable. 2631 """ 2632 return _pywrapcp.IntVar_WhenDomain(self, *args) 2633 2634 def Size(self): 2635 r""" This method returns the number of values in the domain of the variable.""" 2636 return _pywrapcp.IntVar_Size(self) 2637 2638 def Contains(self, v): 2639 r""" 2640 This method returns whether the value 'v' is in the domain of the 2641 variable. 2642 """ 2643 return _pywrapcp.IntVar_Contains(self, v) 2644 2645 def HoleIteratorAux(self, reversible): 2646 r""" 2647 Creates a hole iterator. When 'reversible' is false, the returned 2648 object is created on the normal C++ heap and the solver does NOT 2649 take ownership of the object. 2650 """ 2651 return _pywrapcp.IntVar_HoleIteratorAux(self, reversible) 2652 2653 def DomainIteratorAux(self, reversible): 2654 r""" 2655 Creates a domain iterator. When 'reversible' is false, the 2656 returned object is created on the normal C++ heap and the solver 2657 does NOT take ownership of the object. 2658 """ 2659 return _pywrapcp.IntVar_DomainIteratorAux(self, reversible) 2660 2661 def OldMin(self): 2662 r""" Returns the previous min.""" 2663 return _pywrapcp.IntVar_OldMin(self) 2664 2665 def OldMax(self): 2666 r""" Returns the previous max.""" 2667 return _pywrapcp.IntVar_OldMax(self) 2668 2669 def __repr__(self): 2670 return _pywrapcp.IntVar___repr__(self) 2671 2672 def __str__(self): 2673 return _pywrapcp.IntVar___str__(self) 2674 2675 def DomainIterator(self): 2676 return iter(self.DomainIteratorAux(False)) 2677 2678 def HoleIterator(self): 2679 return iter(self.HoleIteratorAux(False))
The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events.
def
Value(self):
2580 def Value(self): 2581 r""" 2582 This method returns the value of the variable. This method checks 2583 before that the variable is bound. 2584 """ 2585 return _pywrapcp.IntVar_Value(self)
This method returns the value of the variable. This method checks before that the variable is bound.
def
RemoveValue(self, v):
2587 def RemoveValue(self, v): 2588 r""" This method removes the value 'v' from the domain of the variable.""" 2589 return _pywrapcp.IntVar_RemoveValue(self, v)
This method removes the value 'v' from the domain of the variable.
def
RemoveInterval(self, l, u):
2591 def RemoveInterval(self, l, u): 2592 r""" 2593 This method removes the interval 'l' .. 'u' from the domain of 2594 the variable. It assumes that 'l' <= 'u'. 2595 """ 2596 return _pywrapcp.IntVar_RemoveInterval(self, l, u)
This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'.
def
RemoveValues(self, values):
2598 def RemoveValues(self, values): 2599 r""" This method remove the values from the domain of the variable.""" 2600 return _pywrapcp.IntVar_RemoveValues(self, values)
This method remove the values from the domain of the variable.
def
SetValues(self, values):
2602 def SetValues(self, values): 2603 r""" This method intersects the current domain with the values in the array.""" 2604 return _pywrapcp.IntVar_SetValues(self, values)
This method intersects the current domain with the values in the array.
def
WhenBound(self, *args):
2606 def WhenBound(self, *args): 2607 r""" 2608 *Overload 1:* 2609 This method attaches a demon that will be awakened when the 2610 variable is bound. 2611 2612 | 2613 2614 *Overload 2:* 2615 This method attaches a closure that will be awakened when the 2616 variable is bound. 2617 """ 2618 return _pywrapcp.IntVar_WhenBound(self, *args)
Overload 1: This method attaches a demon that will be awakened when the variable is bound.
|
Overload 2: This method attaches a closure that will be awakened when the variable is bound.
def
WhenDomain(self, *args):
2620 def WhenDomain(self, *args): 2621 r""" 2622 *Overload 1:* 2623 This method attaches a demon that will watch any domain 2624 modification of the domain of the variable. 2625 2626 | 2627 2628 *Overload 2:* 2629 This method attaches a closure that will watch any domain 2630 modification of the domain of the variable. 2631 """ 2632 return _pywrapcp.IntVar_WhenDomain(self, *args)
Overload 1: This method attaches a demon that will watch any domain modification of the domain of the variable.
|
Overload 2: This method attaches a closure that will watch any domain modification of the domain of the variable.
def
Size(self):
2634 def Size(self): 2635 r""" This method returns the number of values in the domain of the variable.""" 2636 return _pywrapcp.IntVar_Size(self)
This method returns the number of values in the domain of the variable.
def
Contains(self, v):
2638 def Contains(self, v): 2639 r""" 2640 This method returns whether the value 'v' is in the domain of the 2641 variable. 2642 """ 2643 return _pywrapcp.IntVar_Contains(self, v)
This method returns whether the value 'v' is in the domain of the variable.
def
HoleIteratorAux(self, reversible):
2645 def HoleIteratorAux(self, reversible): 2646 r""" 2647 Creates a hole iterator. When 'reversible' is false, the returned 2648 object is created on the normal C++ heap and the solver does NOT 2649 take ownership of the object. 2650 """ 2651 return _pywrapcp.IntVar_HoleIteratorAux(self, reversible)
Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.
def
DomainIteratorAux(self, reversible):
2653 def DomainIteratorAux(self, reversible): 2654 r""" 2655 Creates a domain iterator. When 'reversible' is false, the 2656 returned object is created on the normal C++ heap and the solver 2657 does NOT take ownership of the object. 2658 """ 2659 return _pywrapcp.IntVar_DomainIteratorAux(self, reversible)
Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.
def
OldMin(self):
2661 def OldMin(self): 2662 r""" Returns the previous min.""" 2663 return _pywrapcp.IntVar_OldMin(self)
Returns the previous min.
def
OldMax(self):
2665 def OldMax(self): 2666 r""" Returns the previous max.""" 2667 return _pywrapcp.IntVar_OldMax(self)
Returns the previous max.
2684class SolutionCollector(SearchMonitor): 2685 r""" 2686 This class is the root class of all solution collectors. 2687 It implements a basic query API to be used independently 2688 of the collector used. 2689 """ 2690 2691 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2692 2693 def __init__(self, *args, **kwargs): 2694 raise AttributeError("No constructor defined") 2695 __repr__ = _swig_repr 2696 2697 def DebugString(self): 2698 return _pywrapcp.SolutionCollector_DebugString(self) 2699 2700 def Add(self, *args): 2701 return _pywrapcp.SolutionCollector_Add(self, *args) 2702 2703 def AddObjective(self, objective): 2704 return _pywrapcp.SolutionCollector_AddObjective(self, objective) 2705 2706 def EnterSearch(self): 2707 r""" Beginning of the search.""" 2708 return _pywrapcp.SolutionCollector_EnterSearch(self) 2709 2710 def SolutionCount(self): 2711 r""" Returns how many solutions were stored during the search.""" 2712 return _pywrapcp.SolutionCollector_SolutionCount(self) 2713 2714 def Solution(self, n): 2715 r""" Returns the nth solution.""" 2716 return _pywrapcp.SolutionCollector_Solution(self, n) 2717 2718 def WallTime(self, n): 2719 r""" Returns the wall time in ms for the nth solution.""" 2720 return _pywrapcp.SolutionCollector_WallTime(self, n) 2721 2722 def Branches(self, n): 2723 r""" Returns the number of branches when the nth solution was found.""" 2724 return _pywrapcp.SolutionCollector_Branches(self, n) 2725 2726 def Failures(self, n): 2727 r""" 2728 Returns the number of failures encountered at the time of the nth 2729 solution. 2730 """ 2731 return _pywrapcp.SolutionCollector_Failures(self, n) 2732 2733 def ObjectiveValue(self, n): 2734 r""" Returns the objective value of the nth solution.""" 2735 return _pywrapcp.SolutionCollector_ObjectiveValue(self, n) 2736 2737 def Value(self, n, var): 2738 r""" This is a shortcut to get the Value of 'var' in the nth solution.""" 2739 return _pywrapcp.SolutionCollector_Value(self, n, var) 2740 2741 def StartValue(self, n, var): 2742 r""" This is a shortcut to get the StartValue of 'var' in the nth solution.""" 2743 return _pywrapcp.SolutionCollector_StartValue(self, n, var) 2744 2745 def EndValue(self, n, var): 2746 r""" This is a shortcut to get the EndValue of 'var' in the nth solution.""" 2747 return _pywrapcp.SolutionCollector_EndValue(self, n, var) 2748 2749 def DurationValue(self, n, var): 2750 r""" This is a shortcut to get the DurationValue of 'var' in the nth solution.""" 2751 return _pywrapcp.SolutionCollector_DurationValue(self, n, var) 2752 2753 def PerformedValue(self, n, var): 2754 r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution.""" 2755 return _pywrapcp.SolutionCollector_PerformedValue(self, n, var) 2756 2757 def ForwardSequence(self, n, var): 2758 r""" 2759 This is a shortcut to get the ForwardSequence of 'var' in the 2760 nth solution. The forward sequence is the list of ranked interval 2761 variables starting from the start of the sequence. 2762 """ 2763 return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var) 2764 2765 def BackwardSequence(self, n, var): 2766 r""" 2767 This is a shortcut to get the BackwardSequence of 'var' in the 2768 nth solution. The backward sequence is the list of ranked interval 2769 variables starting from the end of the sequence. 2770 """ 2771 return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var) 2772 2773 def Unperformed(self, n, var): 2774 r""" 2775 This is a shortcut to get the list of unperformed of 'var' in the 2776 nth solution. 2777 """ 2778 return _pywrapcp.SolutionCollector_Unperformed(self, n, var)
This class is the root class of all solution collectors. It implements a basic query API to be used independently of the collector used.
def
EnterSearch(self):
2706 def EnterSearch(self): 2707 r""" Beginning of the search.""" 2708 return _pywrapcp.SolutionCollector_EnterSearch(self)
Beginning of the search.
def
SolutionCount(self):
2710 def SolutionCount(self): 2711 r""" Returns how many solutions were stored during the search.""" 2712 return _pywrapcp.SolutionCollector_SolutionCount(self)
Returns how many solutions were stored during the search.
def
Solution(self, n):
2714 def Solution(self, n): 2715 r""" Returns the nth solution.""" 2716 return _pywrapcp.SolutionCollector_Solution(self, n)
Returns the nth solution.
def
WallTime(self, n):
2718 def WallTime(self, n): 2719 r""" Returns the wall time in ms for the nth solution.""" 2720 return _pywrapcp.SolutionCollector_WallTime(self, n)
Returns the wall time in ms for the nth solution.
def
Branches(self, n):
2722 def Branches(self, n): 2723 r""" Returns the number of branches when the nth solution was found.""" 2724 return _pywrapcp.SolutionCollector_Branches(self, n)
Returns the number of branches when the nth solution was found.
def
Failures(self, n):
2726 def Failures(self, n): 2727 r""" 2728 Returns the number of failures encountered at the time of the nth 2729 solution. 2730 """ 2731 return _pywrapcp.SolutionCollector_Failures(self, n)
Returns the number of failures encountered at the time of the nth solution.
def
ObjectiveValue(self, n):
2733 def ObjectiveValue(self, n): 2734 r""" Returns the objective value of the nth solution.""" 2735 return _pywrapcp.SolutionCollector_ObjectiveValue(self, n)
Returns the objective value of the nth solution.
def
Value(self, n, var):
2737 def Value(self, n, var): 2738 r""" This is a shortcut to get the Value of 'var' in the nth solution.""" 2739 return _pywrapcp.SolutionCollector_Value(self, n, var)
This is a shortcut to get the Value of 'var' in the nth solution.
def
StartValue(self, n, var):
2741 def StartValue(self, n, var): 2742 r""" This is a shortcut to get the StartValue of 'var' in the nth solution.""" 2743 return _pywrapcp.SolutionCollector_StartValue(self, n, var)
This is a shortcut to get the StartValue of 'var' in the nth solution.
def
EndValue(self, n, var):
2745 def EndValue(self, n, var): 2746 r""" This is a shortcut to get the EndValue of 'var' in the nth solution.""" 2747 return _pywrapcp.SolutionCollector_EndValue(self, n, var)
This is a shortcut to get the EndValue of 'var' in the nth solution.
def
DurationValue(self, n, var):
2749 def DurationValue(self, n, var): 2750 r""" This is a shortcut to get the DurationValue of 'var' in the nth solution.""" 2751 return _pywrapcp.SolutionCollector_DurationValue(self, n, var)
This is a shortcut to get the DurationValue of 'var' in the nth solution.
def
PerformedValue(self, n, var):
2753 def PerformedValue(self, n, var): 2754 r""" This is a shortcut to get the PerformedValue of 'var' in the nth solution.""" 2755 return _pywrapcp.SolutionCollector_PerformedValue(self, n, var)
This is a shortcut to get the PerformedValue of 'var' in the nth solution.
def
ForwardSequence(self, n, var):
2757 def ForwardSequence(self, n, var): 2758 r""" 2759 This is a shortcut to get the ForwardSequence of 'var' in the 2760 nth solution. The forward sequence is the list of ranked interval 2761 variables starting from the start of the sequence. 2762 """ 2763 return _pywrapcp.SolutionCollector_ForwardSequence(self, n, var)
This is a shortcut to get the ForwardSequence of 'var' in the nth solution. The forward sequence is the list of ranked interval variables starting from the start of the sequence.
def
BackwardSequence(self, n, var):
2765 def BackwardSequence(self, n, var): 2766 r""" 2767 This is a shortcut to get the BackwardSequence of 'var' in the 2768 nth solution. The backward sequence is the list of ranked interval 2769 variables starting from the end of the sequence. 2770 """ 2771 return _pywrapcp.SolutionCollector_BackwardSequence(self, n, var)
This is a shortcut to get the BackwardSequence of 'var' in the nth solution. The backward sequence is the list of ranked interval variables starting from the end of the sequence.
def
Unperformed(self, n, var):
2773 def Unperformed(self, n, var): 2774 r""" 2775 This is a shortcut to get the list of unperformed of 'var' in the 2776 nth solution. 2777 """ 2778 return _pywrapcp.SolutionCollector_Unperformed(self, n, var)
This is a shortcut to get the list of unperformed of 'var' in the nth solution.
Inherited Members
class
OptimizeVar:
2782class OptimizeVar(object): 2783 r""" 2784 This class encapsulates an objective. It requires the direction 2785 (minimize or maximize), the variable to optimize, and the 2786 improvement step. 2787 """ 2788 2789 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2790 2791 def __init__(self, *args, **kwargs): 2792 raise AttributeError("No constructor defined") 2793 __repr__ = _swig_repr 2794 2795 def Best(self): 2796 r""" Returns the best value found during search.""" 2797 return _pywrapcp.OptimizeVar_Best(self) 2798 2799 def AcceptDelta(self, delta, deltadelta): 2800 r""" Internal methods.""" 2801 return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta) 2802 2803 def BeginNextDecision(self, db): 2804 return _pywrapcp.OptimizeVar_BeginNextDecision(self, db) 2805 2806 def RefuteDecision(self, d): 2807 return _pywrapcp.OptimizeVar_RefuteDecision(self, d) 2808 2809 def AtSolution(self): 2810 return _pywrapcp.OptimizeVar_AtSolution(self) 2811 2812 def AcceptSolution(self): 2813 return _pywrapcp.OptimizeVar_AcceptSolution(self) 2814 2815 def DebugString(self): 2816 return _pywrapcp.OptimizeVar_DebugString(self) 2817 __swig_destroy__ = _pywrapcp.delete_OptimizeVar
This class encapsulates an objective. It requires the direction (minimize or maximize), the variable to optimize, and the improvement step.
def
Best(self):
2795 def Best(self): 2796 r""" Returns the best value found during search.""" 2797 return _pywrapcp.OptimizeVar_Best(self)
Returns the best value found during search.
def
AcceptDelta(self, delta, deltadelta):
2799 def AcceptDelta(self, delta, deltadelta): 2800 r""" Internal methods.""" 2801 return _pywrapcp.OptimizeVar_AcceptDelta(self, delta, deltadelta)
Internal methods.
2821class SearchLimit(SearchMonitor): 2822 r""" Base class of all search limits.""" 2823 2824 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2825 2826 def __init__(self, *args, **kwargs): 2827 raise AttributeError("No constructor defined - class is abstract") 2828 __repr__ = _swig_repr 2829 __swig_destroy__ = _pywrapcp.delete_SearchLimit 2830 2831 def Crossed(self): 2832 r""" Returns true if the limit has been crossed.""" 2833 return _pywrapcp.SearchLimit_Crossed(self) 2834 2835 def Check(self): 2836 r""" 2837 This method is called to check the status of the limit. A return 2838 value of true indicates that we have indeed crossed the limit. In 2839 that case, this method will not be called again and the remaining 2840 search will be discarded. 2841 """ 2842 return _pywrapcp.SearchLimit_Check(self) 2843 2844 def Init(self): 2845 r""" This method is called when the search limit is initialized.""" 2846 return _pywrapcp.SearchLimit_Init(self) 2847 2848 def EnterSearch(self): 2849 r""" Internal methods.""" 2850 return _pywrapcp.SearchLimit_EnterSearch(self) 2851 2852 def BeginNextDecision(self, b): 2853 return _pywrapcp.SearchLimit_BeginNextDecision(self, b) 2854 2855 def RefuteDecision(self, d): 2856 return _pywrapcp.SearchLimit_RefuteDecision(self, d) 2857 2858 def DebugString(self): 2859 return _pywrapcp.SearchLimit_DebugString(self)
Base class of all search limits.
def
Crossed(self):
2831 def Crossed(self): 2832 r""" Returns true if the limit has been crossed.""" 2833 return _pywrapcp.SearchLimit_Crossed(self)
Returns true if the limit has been crossed.
def
Check(self):
2835 def Check(self): 2836 r""" 2837 This method is called to check the status of the limit. A return 2838 value of true indicates that we have indeed crossed the limit. In 2839 that case, this method will not be called again and the remaining 2840 search will be discarded. 2841 """ 2842 return _pywrapcp.SearchLimit_Check(self)
This method is called to check the status of the limit. A return value of true indicates that we have indeed crossed the limit. In that case, this method will not be called again and the remaining search will be discarded.
def
Init(self):
2844 def Init(self): 2845 r""" This method is called when the search limit is initialized.""" 2846 return _pywrapcp.SearchLimit_Init(self)
This method is called when the search limit is initialized.
def
EnterSearch(self):
2848 def EnterSearch(self): 2849 r""" Internal methods.""" 2850 return _pywrapcp.SearchLimit_EnterSearch(self)
Internal methods.
2863class IntervalVar(PropagationBaseObject): 2864 r""" 2865 Interval variables are often used in scheduling. The main characteristics 2866 of an IntervalVar are the start position, duration, and end 2867 date. All these characteristics can be queried and set, and demons can 2868 be posted on their modifications. 2869 2870 An important aspect is optionality: an IntervalVar can be performed or not. 2871 If unperformed, then it simply does not exist, and its characteristics 2872 cannot be accessed any more. An interval var is automatically marked 2873 as unperformed when it is not consistent anymore (start greater 2874 than end, duration < 0...) 2875 """ 2876 2877 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 2878 2879 def __init__(self, *args, **kwargs): 2880 raise AttributeError("No constructor defined - class is abstract") 2881 2882 def StartMin(self): 2883 r""" 2884 These methods query, set, and watch the start position of the 2885 interval var. 2886 """ 2887 return _pywrapcp.IntervalVar_StartMin(self) 2888 2889 def StartMax(self): 2890 return _pywrapcp.IntervalVar_StartMax(self) 2891 2892 def SetStartMin(self, m): 2893 return _pywrapcp.IntervalVar_SetStartMin(self, m) 2894 2895 def SetStartMax(self, m): 2896 return _pywrapcp.IntervalVar_SetStartMax(self, m) 2897 2898 def SetStartRange(self, mi, ma): 2899 return _pywrapcp.IntervalVar_SetStartRange(self, mi, ma) 2900 2901 def OldStartMin(self): 2902 return _pywrapcp.IntervalVar_OldStartMin(self) 2903 2904 def OldStartMax(self): 2905 return _pywrapcp.IntervalVar_OldStartMax(self) 2906 2907 def WhenStartRange(self, *args): 2908 return _pywrapcp.IntervalVar_WhenStartRange(self, *args) 2909 2910 def WhenStartBound(self, *args): 2911 return _pywrapcp.IntervalVar_WhenStartBound(self, *args) 2912 2913 def DurationMin(self): 2914 r""" These methods query, set, and watch the duration of the interval var.""" 2915 return _pywrapcp.IntervalVar_DurationMin(self) 2916 2917 def DurationMax(self): 2918 return _pywrapcp.IntervalVar_DurationMax(self) 2919 2920 def SetDurationMin(self, m): 2921 return _pywrapcp.IntervalVar_SetDurationMin(self, m) 2922 2923 def SetDurationMax(self, m): 2924 return _pywrapcp.IntervalVar_SetDurationMax(self, m) 2925 2926 def SetDurationRange(self, mi, ma): 2927 return _pywrapcp.IntervalVar_SetDurationRange(self, mi, ma) 2928 2929 def OldDurationMin(self): 2930 return _pywrapcp.IntervalVar_OldDurationMin(self) 2931 2932 def OldDurationMax(self): 2933 return _pywrapcp.IntervalVar_OldDurationMax(self) 2934 2935 def WhenDurationRange(self, *args): 2936 return _pywrapcp.IntervalVar_WhenDurationRange(self, *args) 2937 2938 def WhenDurationBound(self, *args): 2939 return _pywrapcp.IntervalVar_WhenDurationBound(self, *args) 2940 2941 def EndMin(self): 2942 r""" These methods query, set, and watch the end position of the interval var.""" 2943 return _pywrapcp.IntervalVar_EndMin(self) 2944 2945 def EndMax(self): 2946 return _pywrapcp.IntervalVar_EndMax(self) 2947 2948 def SetEndMin(self, m): 2949 return _pywrapcp.IntervalVar_SetEndMin(self, m) 2950 2951 def SetEndMax(self, m): 2952 return _pywrapcp.IntervalVar_SetEndMax(self, m) 2953 2954 def SetEndRange(self, mi, ma): 2955 return _pywrapcp.IntervalVar_SetEndRange(self, mi, ma) 2956 2957 def OldEndMin(self): 2958 return _pywrapcp.IntervalVar_OldEndMin(self) 2959 2960 def OldEndMax(self): 2961 return _pywrapcp.IntervalVar_OldEndMax(self) 2962 2963 def WhenEndRange(self, *args): 2964 return _pywrapcp.IntervalVar_WhenEndRange(self, *args) 2965 2966 def WhenEndBound(self, *args): 2967 return _pywrapcp.IntervalVar_WhenEndBound(self, *args) 2968 2969 def MustBePerformed(self): 2970 r""" 2971 These methods query, set, and watch the performed status of the 2972 interval var. 2973 """ 2974 return _pywrapcp.IntervalVar_MustBePerformed(self) 2975 2976 def MayBePerformed(self): 2977 return _pywrapcp.IntervalVar_MayBePerformed(self) 2978 2979 def CannotBePerformed(self): 2980 return _pywrapcp.IntervalVar_CannotBePerformed(self) 2981 2982 def IsPerformedBound(self): 2983 return _pywrapcp.IntervalVar_IsPerformedBound(self) 2984 2985 def SetPerformed(self, val): 2986 return _pywrapcp.IntervalVar_SetPerformed(self, val) 2987 2988 def WasPerformedBound(self): 2989 return _pywrapcp.IntervalVar_WasPerformedBound(self) 2990 2991 def WhenPerformedBound(self, *args): 2992 return _pywrapcp.IntervalVar_WhenPerformedBound(self, *args) 2993 2994 def WhenAnything(self, *args): 2995 r""" 2996 *Overload 1:* 2997 Attaches a demon awakened when anything about this interval changes. 2998 2999 | 3000 3001 *Overload 2:* 3002 Attaches a closure awakened when anything about this interval changes. 3003 """ 3004 return _pywrapcp.IntervalVar_WhenAnything(self, *args) 3005 3006 def StartExpr(self): 3007 r""" 3008 These methods create expressions encapsulating the start, end 3009 and duration of the interval var. Please note that these must not 3010 be used if the interval var is unperformed. 3011 """ 3012 return _pywrapcp.IntervalVar_StartExpr(self) 3013 3014 def DurationExpr(self): 3015 return _pywrapcp.IntervalVar_DurationExpr(self) 3016 3017 def EndExpr(self): 3018 return _pywrapcp.IntervalVar_EndExpr(self) 3019 3020 def PerformedExpr(self): 3021 return _pywrapcp.IntervalVar_PerformedExpr(self) 3022 3023 def SafeStartExpr(self, unperformed_value): 3024 r""" 3025 These methods create expressions encapsulating the start, end 3026 and duration of the interval var. If the interval var is 3027 unperformed, they will return the unperformed_value. 3028 """ 3029 return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value) 3030 3031 def SafeDurationExpr(self, unperformed_value): 3032 return _pywrapcp.IntervalVar_SafeDurationExpr(self, unperformed_value) 3033 3034 def SafeEndExpr(self, unperformed_value): 3035 return _pywrapcp.IntervalVar_SafeEndExpr(self, unperformed_value) 3036 3037 def EndsAfterEnd(self, other): 3038 return _pywrapcp.IntervalVar_EndsAfterEnd(self, other) 3039 3040 def EndsAfterEndWithDelay(self, other, delay): 3041 return _pywrapcp.IntervalVar_EndsAfterEndWithDelay(self, other, delay) 3042 3043 def EndsAfterStart(self, other): 3044 return _pywrapcp.IntervalVar_EndsAfterStart(self, other) 3045 3046 def EndsAfterStartWithDelay(self, other, delay): 3047 return _pywrapcp.IntervalVar_EndsAfterStartWithDelay(self, other, delay) 3048 3049 def EndsAtEnd(self, other): 3050 return _pywrapcp.IntervalVar_EndsAtEnd(self, other) 3051 3052 def EndsAtEndWithDelay(self, other, delay): 3053 return _pywrapcp.IntervalVar_EndsAtEndWithDelay(self, other, delay) 3054 3055 def EndsAtStart(self, other): 3056 return _pywrapcp.IntervalVar_EndsAtStart(self, other) 3057 3058 def EndsAtStartWithDelay(self, other, delay): 3059 return _pywrapcp.IntervalVar_EndsAtStartWithDelay(self, other, delay) 3060 3061 def StartsAfterEnd(self, other): 3062 return _pywrapcp.IntervalVar_StartsAfterEnd(self, other) 3063 3064 def StartsAfterEndWithDelay(self, other, delay): 3065 return _pywrapcp.IntervalVar_StartsAfterEndWithDelay(self, other, delay) 3066 3067 def StartsAfterStart(self, other): 3068 return _pywrapcp.IntervalVar_StartsAfterStart(self, other) 3069 3070 def StartsAfterStartWithDelay(self, other, delay): 3071 return _pywrapcp.IntervalVar_StartsAfterStartWithDelay(self, other, delay) 3072 3073 def StartsAtEnd(self, other): 3074 return _pywrapcp.IntervalVar_StartsAtEnd(self, other) 3075 3076 def StartsAtEndWithDelay(self, other, delay): 3077 return _pywrapcp.IntervalVar_StartsAtEndWithDelay(self, other, delay) 3078 3079 def StartsAtStart(self, other): 3080 return _pywrapcp.IntervalVar_StartsAtStart(self, other) 3081 3082 def StartsAtStartWithDelay(self, other, delay): 3083 return _pywrapcp.IntervalVar_StartsAtStartWithDelay(self, other, delay) 3084 3085 def StaysInSync(self, other): 3086 return _pywrapcp.IntervalVar_StaysInSync(self, other) 3087 3088 def StaysInSyncWithDelay(self, other, delay): 3089 return _pywrapcp.IntervalVar_StaysInSyncWithDelay(self, other, delay) 3090 3091 def EndsAfter(self, date): 3092 return _pywrapcp.IntervalVar_EndsAfter(self, date) 3093 3094 def EndsAt(self, date): 3095 return _pywrapcp.IntervalVar_EndsAt(self, date) 3096 3097 def EndsBefore(self, date): 3098 return _pywrapcp.IntervalVar_EndsBefore(self, date) 3099 3100 def StartsAfter(self, date): 3101 return _pywrapcp.IntervalVar_StartsAfter(self, date) 3102 3103 def StartsAt(self, date): 3104 return _pywrapcp.IntervalVar_StartsAt(self, date) 3105 3106 def StartsBefore(self, date): 3107 return _pywrapcp.IntervalVar_StartsBefore(self, date) 3108 3109 def CrossesDate(self, date): 3110 return _pywrapcp.IntervalVar_CrossesDate(self, date) 3111 3112 def AvoidsDate(self, date): 3113 return _pywrapcp.IntervalVar_AvoidsDate(self, date) 3114 3115 def __repr__(self): 3116 return _pywrapcp.IntervalVar___repr__(self) 3117 3118 def __str__(self): 3119 return _pywrapcp.IntervalVar___str__(self)
Interval variables are often used in scheduling. The main characteristics of an IntervalVar are the start position, duration, and end date. All these characteristics can be queried and set, and demons can be posted on their modifications.
An important aspect is optionality: an IntervalVar can be performed or not. If unperformed, then it simply does not exist, and its characteristics cannot be accessed any more. An interval var is automatically marked as unperformed when it is not consistent anymore (start greater than end, duration < 0...)
def
StartMin(self):
2882 def StartMin(self): 2883 r""" 2884 These methods query, set, and watch the start position of the 2885 interval var. 2886 """ 2887 return _pywrapcp.IntervalVar_StartMin(self)
These methods query, set, and watch the start position of the interval var.
def
DurationMin(self):
2913 def DurationMin(self): 2914 r""" These methods query, set, and watch the duration of the interval var.""" 2915 return _pywrapcp.IntervalVar_DurationMin(self)
These methods query, set, and watch the duration of the interval var.
def
EndMin(self):
2941 def EndMin(self): 2942 r""" These methods query, set, and watch the end position of the interval var.""" 2943 return _pywrapcp.IntervalVar_EndMin(self)
These methods query, set, and watch the end position of the interval var.
def
MustBePerformed(self):
2969 def MustBePerformed(self): 2970 r""" 2971 These methods query, set, and watch the performed status of the 2972 interval var. 2973 """ 2974 return _pywrapcp.IntervalVar_MustBePerformed(self)
These methods query, set, and watch the performed status of the interval var.
def
WhenAnything(self, *args):
2994 def WhenAnything(self, *args): 2995 r""" 2996 *Overload 1:* 2997 Attaches a demon awakened when anything about this interval changes. 2998 2999 | 3000 3001 *Overload 2:* 3002 Attaches a closure awakened when anything about this interval changes. 3003 """ 3004 return _pywrapcp.IntervalVar_WhenAnything(self, *args)
Overload 1: Attaches a demon awakened when anything about this interval changes.
|
Overload 2: Attaches a closure awakened when anything about this interval changes.
def
StartExpr(self):
3006 def StartExpr(self): 3007 r""" 3008 These methods create expressions encapsulating the start, end 3009 and duration of the interval var. Please note that these must not 3010 be used if the interval var is unperformed. 3011 """ 3012 return _pywrapcp.IntervalVar_StartExpr(self)
These methods create expressions encapsulating the start, end and duration of the interval var. Please note that these must not be used if the interval var is unperformed.
def
SafeStartExpr(self, unperformed_value):
3023 def SafeStartExpr(self, unperformed_value): 3024 r""" 3025 These methods create expressions encapsulating the start, end 3026 and duration of the interval var. If the interval var is 3027 unperformed, they will return the unperformed_value. 3028 """ 3029 return _pywrapcp.IntervalVar_SafeStartExpr(self, unperformed_value)
These methods create expressions encapsulating the start, end and duration of the interval var. If the interval var is unperformed, they will return the unperformed_value.
Inherited Members
3123class SequenceVar(PropagationBaseObject): 3124 r""" 3125 A sequence variable is a variable whose domain is a set of possible 3126 orderings of the interval variables. It allows ordering of tasks. It 3127 has two sets of methods: ComputePossibleFirstsAndLasts(), which 3128 returns the list of interval variables that can be ranked first or 3129 last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be 3130 used to create the search decision. 3131 """ 3132 3133 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3134 3135 def __init__(self, *args, **kwargs): 3136 raise AttributeError("No constructor defined") 3137 3138 def DebugString(self): 3139 return _pywrapcp.SequenceVar_DebugString(self) 3140 3141 def RankFirst(self, index): 3142 r""" 3143 Ranks the index_th interval var first of all unranked interval 3144 vars. After that, it will no longer be considered ranked. 3145 """ 3146 return _pywrapcp.SequenceVar_RankFirst(self, index) 3147 3148 def RankNotFirst(self, index): 3149 r""" 3150 Indicates that the index_th interval var will not be ranked first 3151 of all currently unranked interval vars. 3152 """ 3153 return _pywrapcp.SequenceVar_RankNotFirst(self, index) 3154 3155 def RankLast(self, index): 3156 r""" 3157 Ranks the index_th interval var first of all unranked interval 3158 vars. After that, it will no longer be considered ranked. 3159 """ 3160 return _pywrapcp.SequenceVar_RankLast(self, index) 3161 3162 def RankNotLast(self, index): 3163 r""" 3164 Indicates that the index_th interval var will not be ranked first 3165 of all currently unranked interval vars. 3166 """ 3167 return _pywrapcp.SequenceVar_RankNotLast(self, index) 3168 3169 def Interval(self, index): 3170 r""" Returns the index_th interval of the sequence.""" 3171 return _pywrapcp.SequenceVar_Interval(self, index) 3172 3173 def Next(self, index): 3174 r""" Returns the next of the index_th interval of the sequence.""" 3175 return _pywrapcp.SequenceVar_Next(self, index) 3176 3177 def Size(self): 3178 r""" Returns the number of interval vars in the sequence.""" 3179 return _pywrapcp.SequenceVar_Size(self) 3180 3181 def __repr__(self): 3182 return _pywrapcp.SequenceVar___repr__(self) 3183 3184 def __str__(self): 3185 return _pywrapcp.SequenceVar___str__(self)
A sequence variable is a variable whose domain is a set of possible orderings of the interval variables. It allows ordering of tasks. It has two sets of methods: ComputePossibleFirstsAndLasts(), which returns the list of interval variables that can be ranked first or last; and RankFirst/RankNotFirst/RankLast/RankNotLast, which can be used to create the search decision.
def
RankFirst(self, index):
3141 def RankFirst(self, index): 3142 r""" 3143 Ranks the index_th interval var first of all unranked interval 3144 vars. After that, it will no longer be considered ranked. 3145 """ 3146 return _pywrapcp.SequenceVar_RankFirst(self, index)
Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.
def
RankNotFirst(self, index):
3148 def RankNotFirst(self, index): 3149 r""" 3150 Indicates that the index_th interval var will not be ranked first 3151 of all currently unranked interval vars. 3152 """ 3153 return _pywrapcp.SequenceVar_RankNotFirst(self, index)
Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.
def
RankLast(self, index):
3155 def RankLast(self, index): 3156 r""" 3157 Ranks the index_th interval var first of all unranked interval 3158 vars. After that, it will no longer be considered ranked. 3159 """ 3160 return _pywrapcp.SequenceVar_RankLast(self, index)
Ranks the index_th interval var first of all unranked interval vars. After that, it will no longer be considered ranked.
def
RankNotLast(self, index):
3162 def RankNotLast(self, index): 3163 r""" 3164 Indicates that the index_th interval var will not be ranked first 3165 of all currently unranked interval vars. 3166 """ 3167 return _pywrapcp.SequenceVar_RankNotLast(self, index)
Indicates that the index_th interval var will not be ranked first of all currently unranked interval vars.
def
Interval(self, index):
3169 def Interval(self, index): 3170 r""" Returns the index_th interval of the sequence.""" 3171 return _pywrapcp.SequenceVar_Interval(self, index)
Returns the index_th interval of the sequence.
def
Next(self, index):
3173 def Next(self, index): 3174 r""" Returns the next of the index_th interval of the sequence.""" 3175 return _pywrapcp.SequenceVar_Next(self, index)
Returns the next of the index_th interval of the sequence.
def
Size(self):
3177 def Size(self): 3178 r""" Returns the number of interval vars in the sequence.""" 3179 return _pywrapcp.SequenceVar_Size(self)
Returns the number of interval vars in the sequence.
Inherited Members
class
AssignmentElement:
3189class AssignmentElement(object): 3190 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3191 3192 def __init__(self, *args, **kwargs): 3193 raise AttributeError("No constructor defined") 3194 __repr__ = _swig_repr 3195 3196 def Activate(self): 3197 return _pywrapcp.AssignmentElement_Activate(self) 3198 3199 def Deactivate(self): 3200 return _pywrapcp.AssignmentElement_Deactivate(self) 3201 3202 def Activated(self): 3203 return _pywrapcp.AssignmentElement_Activated(self) 3204 __swig_destroy__ = _pywrapcp.delete_AssignmentElement
3208class IntVarElement(AssignmentElement): 3209 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3210 3211 def __init__(self, *args, **kwargs): 3212 raise AttributeError("No constructor defined") 3213 __repr__ = _swig_repr 3214 3215 def Var(self): 3216 return _pywrapcp.IntVarElement_Var(self) 3217 3218 def Min(self): 3219 return _pywrapcp.IntVarElement_Min(self) 3220 3221 def SetMin(self, m): 3222 return _pywrapcp.IntVarElement_SetMin(self, m) 3223 3224 def Max(self): 3225 return _pywrapcp.IntVarElement_Max(self) 3226 3227 def SetMax(self, m): 3228 return _pywrapcp.IntVarElement_SetMax(self, m) 3229 3230 def Value(self): 3231 return _pywrapcp.IntVarElement_Value(self) 3232 3233 def Bound(self): 3234 return _pywrapcp.IntVarElement_Bound(self) 3235 3236 def SetRange(self, l, u): 3237 return _pywrapcp.IntVarElement_SetRange(self, l, u) 3238 3239 def SetValue(self, v): 3240 return _pywrapcp.IntVarElement_SetValue(self, v) 3241 3242 def __eq__(self, element): 3243 return _pywrapcp.IntVarElement___eq__(self, element) 3244 3245 def __ne__(self, element): 3246 return _pywrapcp.IntVarElement___ne__(self, element) 3247 __swig_destroy__ = _pywrapcp.delete_IntVarElement
Inherited Members
3251class IntervalVarElement(AssignmentElement): 3252 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3253 3254 def __init__(self, *args, **kwargs): 3255 raise AttributeError("No constructor defined") 3256 __repr__ = _swig_repr 3257 3258 def Var(self): 3259 return _pywrapcp.IntervalVarElement_Var(self) 3260 3261 def StartMin(self): 3262 return _pywrapcp.IntervalVarElement_StartMin(self) 3263 3264 def StartMax(self): 3265 return _pywrapcp.IntervalVarElement_StartMax(self) 3266 3267 def StartValue(self): 3268 return _pywrapcp.IntervalVarElement_StartValue(self) 3269 3270 def DurationMin(self): 3271 return _pywrapcp.IntervalVarElement_DurationMin(self) 3272 3273 def DurationMax(self): 3274 return _pywrapcp.IntervalVarElement_DurationMax(self) 3275 3276 def DurationValue(self): 3277 return _pywrapcp.IntervalVarElement_DurationValue(self) 3278 3279 def EndMin(self): 3280 return _pywrapcp.IntervalVarElement_EndMin(self) 3281 3282 def EndMax(self): 3283 return _pywrapcp.IntervalVarElement_EndMax(self) 3284 3285 def EndValue(self): 3286 return _pywrapcp.IntervalVarElement_EndValue(self) 3287 3288 def PerformedMin(self): 3289 return _pywrapcp.IntervalVarElement_PerformedMin(self) 3290 3291 def PerformedMax(self): 3292 return _pywrapcp.IntervalVarElement_PerformedMax(self) 3293 3294 def PerformedValue(self): 3295 return _pywrapcp.IntervalVarElement_PerformedValue(self) 3296 3297 def SetStartMin(self, m): 3298 return _pywrapcp.IntervalVarElement_SetStartMin(self, m) 3299 3300 def SetStartMax(self, m): 3301 return _pywrapcp.IntervalVarElement_SetStartMax(self, m) 3302 3303 def SetStartRange(self, mi, ma): 3304 return _pywrapcp.IntervalVarElement_SetStartRange(self, mi, ma) 3305 3306 def SetStartValue(self, v): 3307 return _pywrapcp.IntervalVarElement_SetStartValue(self, v) 3308 3309 def SetDurationMin(self, m): 3310 return _pywrapcp.IntervalVarElement_SetDurationMin(self, m) 3311 3312 def SetDurationMax(self, m): 3313 return _pywrapcp.IntervalVarElement_SetDurationMax(self, m) 3314 3315 def SetDurationRange(self, mi, ma): 3316 return _pywrapcp.IntervalVarElement_SetDurationRange(self, mi, ma) 3317 3318 def SetDurationValue(self, v): 3319 return _pywrapcp.IntervalVarElement_SetDurationValue(self, v) 3320 3321 def SetEndMin(self, m): 3322 return _pywrapcp.IntervalVarElement_SetEndMin(self, m) 3323 3324 def SetEndMax(self, m): 3325 return _pywrapcp.IntervalVarElement_SetEndMax(self, m) 3326 3327 def SetEndRange(self, mi, ma): 3328 return _pywrapcp.IntervalVarElement_SetEndRange(self, mi, ma) 3329 3330 def SetEndValue(self, v): 3331 return _pywrapcp.IntervalVarElement_SetEndValue(self, v) 3332 3333 def SetPerformedMin(self, m): 3334 return _pywrapcp.IntervalVarElement_SetPerformedMin(self, m) 3335 3336 def SetPerformedMax(self, m): 3337 return _pywrapcp.IntervalVarElement_SetPerformedMax(self, m) 3338 3339 def SetPerformedRange(self, mi, ma): 3340 return _pywrapcp.IntervalVarElement_SetPerformedRange(self, mi, ma) 3341 3342 def SetPerformedValue(self, v): 3343 return _pywrapcp.IntervalVarElement_SetPerformedValue(self, v) 3344 3345 def __eq__(self, element): 3346 return _pywrapcp.IntervalVarElement___eq__(self, element) 3347 3348 def __ne__(self, element): 3349 return _pywrapcp.IntervalVarElement___ne__(self, element) 3350 __swig_destroy__ = _pywrapcp.delete_IntervalVarElement
Inherited Members
3354class SequenceVarElement(AssignmentElement): 3355 r""" 3356 The SequenceVarElement stores a partial representation of ranked 3357 interval variables in the underlying sequence variable. 3358 This representation consists of three vectors: 3359 - the forward sequence. That is the list of interval variables 3360 ranked first in the sequence. The first element of the backward 3361 sequence is the first interval in the sequence variable. 3362 - the backward sequence. That is the list of interval variables 3363 ranked last in the sequence. The first element of the backward 3364 sequence is the last interval in the sequence variable. 3365 - The list of unperformed interval variables. 3366 Furthermore, if all performed variables are ranked, then by 3367 convention, the forward_sequence will contain all such variables 3368 and the backward_sequence will be empty. 3369 """ 3370 3371 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3372 3373 def __init__(self, *args, **kwargs): 3374 raise AttributeError("No constructor defined") 3375 __repr__ = _swig_repr 3376 3377 def Var(self): 3378 return _pywrapcp.SequenceVarElement_Var(self) 3379 3380 def ForwardSequence(self): 3381 return _pywrapcp.SequenceVarElement_ForwardSequence(self) 3382 3383 def BackwardSequence(self): 3384 return _pywrapcp.SequenceVarElement_BackwardSequence(self) 3385 3386 def Unperformed(self): 3387 return _pywrapcp.SequenceVarElement_Unperformed(self) 3388 3389 def SetSequence(self, forward_sequence, backward_sequence, unperformed): 3390 return _pywrapcp.SequenceVarElement_SetSequence(self, forward_sequence, backward_sequence, unperformed) 3391 3392 def SetForwardSequence(self, forward_sequence): 3393 return _pywrapcp.SequenceVarElement_SetForwardSequence(self, forward_sequence) 3394 3395 def SetBackwardSequence(self, backward_sequence): 3396 return _pywrapcp.SequenceVarElement_SetBackwardSequence(self, backward_sequence) 3397 3398 def SetUnperformed(self, unperformed): 3399 return _pywrapcp.SequenceVarElement_SetUnperformed(self, unperformed) 3400 3401 def __eq__(self, element): 3402 return _pywrapcp.SequenceVarElement___eq__(self, element) 3403 3404 def __ne__(self, element): 3405 return _pywrapcp.SequenceVarElement___ne__(self, element) 3406 __swig_destroy__ = _pywrapcp.delete_SequenceVarElement
The SequenceVarElement stores a partial representation of ranked interval variables in the underlying sequence variable.
This representation consists of three vectors:
- the forward sequence. That is the list of interval variables ranked first in the sequence. The first element of the backward sequence is the first interval in the sequence variable.
- the backward sequence. That is the list of interval variables ranked last in the sequence. The first element of the backward sequence is the last interval in the sequence variable.
- The list of unperformed interval variables. Furthermore, if all performed variables are ranked, then by convention, the forward_sequence will contain all such variables and the backward_sequence will be empty.
Inherited Members
3410class Assignment(PropagationBaseObject): 3411 r""" 3412 An Assignment is a variable -> domains mapping, used 3413 to report solutions to the user. 3414 """ 3415 3416 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3417 3418 def __init__(self, *args, **kwargs): 3419 raise AttributeError("No constructor defined") 3420 __repr__ = _swig_repr 3421 3422 def Clear(self): 3423 return _pywrapcp.Assignment_Clear(self) 3424 3425 def Empty(self): 3426 return _pywrapcp.Assignment_Empty(self) 3427 3428 def Size(self): 3429 return _pywrapcp.Assignment_Size(self) 3430 3431 def NumIntVars(self): 3432 return _pywrapcp.Assignment_NumIntVars(self) 3433 3434 def NumIntervalVars(self): 3435 return _pywrapcp.Assignment_NumIntervalVars(self) 3436 3437 def NumSequenceVars(self): 3438 return _pywrapcp.Assignment_NumSequenceVars(self) 3439 3440 def Store(self): 3441 return _pywrapcp.Assignment_Store(self) 3442 3443 def Restore(self): 3444 return _pywrapcp.Assignment_Restore(self) 3445 3446 def Load(self, *args): 3447 return _pywrapcp.Assignment_Load(self, *args) 3448 3449 def Save(self, *args): 3450 return _pywrapcp.Assignment_Save(self, *args) 3451 3452 def AddObjective(self, v): 3453 return _pywrapcp.Assignment_AddObjective(self, v) 3454 3455 def Objective(self): 3456 return _pywrapcp.Assignment_Objective(self) 3457 3458 def HasObjective(self): 3459 return _pywrapcp.Assignment_HasObjective(self) 3460 3461 def ObjectiveMin(self): 3462 return _pywrapcp.Assignment_ObjectiveMin(self) 3463 3464 def ObjectiveMax(self): 3465 return _pywrapcp.Assignment_ObjectiveMax(self) 3466 3467 def ObjectiveValue(self): 3468 return _pywrapcp.Assignment_ObjectiveValue(self) 3469 3470 def ObjectiveBound(self): 3471 return _pywrapcp.Assignment_ObjectiveBound(self) 3472 3473 def SetObjectiveMin(self, m): 3474 return _pywrapcp.Assignment_SetObjectiveMin(self, m) 3475 3476 def SetObjectiveMax(self, m): 3477 return _pywrapcp.Assignment_SetObjectiveMax(self, m) 3478 3479 def SetObjectiveValue(self, value): 3480 return _pywrapcp.Assignment_SetObjectiveValue(self, value) 3481 3482 def SetObjectiveRange(self, l, u): 3483 return _pywrapcp.Assignment_SetObjectiveRange(self, l, u) 3484 3485 def Min(self, var): 3486 return _pywrapcp.Assignment_Min(self, var) 3487 3488 def Max(self, var): 3489 return _pywrapcp.Assignment_Max(self, var) 3490 3491 def Value(self, var): 3492 return _pywrapcp.Assignment_Value(self, var) 3493 3494 def Bound(self, var): 3495 return _pywrapcp.Assignment_Bound(self, var) 3496 3497 def SetMin(self, var, m): 3498 return _pywrapcp.Assignment_SetMin(self, var, m) 3499 3500 def SetMax(self, var, m): 3501 return _pywrapcp.Assignment_SetMax(self, var, m) 3502 3503 def SetRange(self, var, l, u): 3504 return _pywrapcp.Assignment_SetRange(self, var, l, u) 3505 3506 def SetValue(self, var, value): 3507 return _pywrapcp.Assignment_SetValue(self, var, value) 3508 3509 def StartMin(self, var): 3510 return _pywrapcp.Assignment_StartMin(self, var) 3511 3512 def StartMax(self, var): 3513 return _pywrapcp.Assignment_StartMax(self, var) 3514 3515 def StartValue(self, var): 3516 return _pywrapcp.Assignment_StartValue(self, var) 3517 3518 def DurationMin(self, var): 3519 return _pywrapcp.Assignment_DurationMin(self, var) 3520 3521 def DurationMax(self, var): 3522 return _pywrapcp.Assignment_DurationMax(self, var) 3523 3524 def DurationValue(self, var): 3525 return _pywrapcp.Assignment_DurationValue(self, var) 3526 3527 def EndMin(self, var): 3528 return _pywrapcp.Assignment_EndMin(self, var) 3529 3530 def EndMax(self, var): 3531 return _pywrapcp.Assignment_EndMax(self, var) 3532 3533 def EndValue(self, var): 3534 return _pywrapcp.Assignment_EndValue(self, var) 3535 3536 def PerformedMin(self, var): 3537 return _pywrapcp.Assignment_PerformedMin(self, var) 3538 3539 def PerformedMax(self, var): 3540 return _pywrapcp.Assignment_PerformedMax(self, var) 3541 3542 def PerformedValue(self, var): 3543 return _pywrapcp.Assignment_PerformedValue(self, var) 3544 3545 def SetStartMin(self, var, m): 3546 return _pywrapcp.Assignment_SetStartMin(self, var, m) 3547 3548 def SetStartMax(self, var, m): 3549 return _pywrapcp.Assignment_SetStartMax(self, var, m) 3550 3551 def SetStartRange(self, var, mi, ma): 3552 return _pywrapcp.Assignment_SetStartRange(self, var, mi, ma) 3553 3554 def SetStartValue(self, var, value): 3555 return _pywrapcp.Assignment_SetStartValue(self, var, value) 3556 3557 def SetDurationMin(self, var, m): 3558 return _pywrapcp.Assignment_SetDurationMin(self, var, m) 3559 3560 def SetDurationMax(self, var, m): 3561 return _pywrapcp.Assignment_SetDurationMax(self, var, m) 3562 3563 def SetDurationRange(self, var, mi, ma): 3564 return _pywrapcp.Assignment_SetDurationRange(self, var, mi, ma) 3565 3566 def SetDurationValue(self, var, value): 3567 return _pywrapcp.Assignment_SetDurationValue(self, var, value) 3568 3569 def SetEndMin(self, var, m): 3570 return _pywrapcp.Assignment_SetEndMin(self, var, m) 3571 3572 def SetEndMax(self, var, m): 3573 return _pywrapcp.Assignment_SetEndMax(self, var, m) 3574 3575 def SetEndRange(self, var, mi, ma): 3576 return _pywrapcp.Assignment_SetEndRange(self, var, mi, ma) 3577 3578 def SetEndValue(self, var, value): 3579 return _pywrapcp.Assignment_SetEndValue(self, var, value) 3580 3581 def SetPerformedMin(self, var, m): 3582 return _pywrapcp.Assignment_SetPerformedMin(self, var, m) 3583 3584 def SetPerformedMax(self, var, m): 3585 return _pywrapcp.Assignment_SetPerformedMax(self, var, m) 3586 3587 def SetPerformedRange(self, var, mi, ma): 3588 return _pywrapcp.Assignment_SetPerformedRange(self, var, mi, ma) 3589 3590 def SetPerformedValue(self, var, value): 3591 return _pywrapcp.Assignment_SetPerformedValue(self, var, value) 3592 3593 def Add(self, *args): 3594 return _pywrapcp.Assignment_Add(self, *args) 3595 3596 def ForwardSequence(self, var): 3597 return _pywrapcp.Assignment_ForwardSequence(self, var) 3598 3599 def BackwardSequence(self, var): 3600 return _pywrapcp.Assignment_BackwardSequence(self, var) 3601 3602 def Unperformed(self, var): 3603 return _pywrapcp.Assignment_Unperformed(self, var) 3604 3605 def SetSequence(self, var, forward_sequence, backward_sequence, unperformed): 3606 return _pywrapcp.Assignment_SetSequence(self, var, forward_sequence, backward_sequence, unperformed) 3607 3608 def SetForwardSequence(self, var, forward_sequence): 3609 return _pywrapcp.Assignment_SetForwardSequence(self, var, forward_sequence) 3610 3611 def SetBackwardSequence(self, var, backward_sequence): 3612 return _pywrapcp.Assignment_SetBackwardSequence(self, var, backward_sequence) 3613 3614 def SetUnperformed(self, var, unperformed): 3615 return _pywrapcp.Assignment_SetUnperformed(self, var, unperformed) 3616 3617 def Activate(self, *args): 3618 return _pywrapcp.Assignment_Activate(self, *args) 3619 3620 def Deactivate(self, *args): 3621 return _pywrapcp.Assignment_Deactivate(self, *args) 3622 3623 def Activated(self, *args): 3624 return _pywrapcp.Assignment_Activated(self, *args) 3625 3626 def DebugString(self): 3627 return _pywrapcp.Assignment_DebugString(self) 3628 3629 def IntVarContainer(self): 3630 return _pywrapcp.Assignment_IntVarContainer(self) 3631 3632 def MutableIntVarContainer(self): 3633 return _pywrapcp.Assignment_MutableIntVarContainer(self) 3634 3635 def IntervalVarContainer(self): 3636 return _pywrapcp.Assignment_IntervalVarContainer(self) 3637 3638 def MutableIntervalVarContainer(self): 3639 return _pywrapcp.Assignment_MutableIntervalVarContainer(self) 3640 3641 def SequenceVarContainer(self): 3642 return _pywrapcp.Assignment_SequenceVarContainer(self) 3643 3644 def MutableSequenceVarContainer(self): 3645 return _pywrapcp.Assignment_MutableSequenceVarContainer(self) 3646 3647 def __eq__(self, assignment): 3648 return _pywrapcp.Assignment___eq__(self, assignment) 3649 3650 def __ne__(self, assignment): 3651 return _pywrapcp.Assignment___ne__(self, assignment)
An Assignment is a variable -> domains mapping, used to report solutions to the user.
Inherited Members
3658class Pack(Constraint): 3659 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3660 3661 def __init__(self, *args, **kwargs): 3662 raise AttributeError("No constructor defined") 3663 __repr__ = _swig_repr 3664 3665 def AddWeightedSumLessOrEqualConstantDimension(self, *args): 3666 r""" 3667 *Overload 1:* 3668 Dimensions are additional constraints than can restrict what is 3669 possible with the pack constraint. It can be used to set capacity 3670 limits, to count objects per bin, to compute unassigned 3671 penalties... 3672 This dimension imposes that for all bins b, the weighted sum 3673 (weights[i]) of all objects i assigned to 'b' is less or equal 3674 'bounds[b]'. 3675 3676 | 3677 3678 *Overload 2:* 3679 This dimension imposes that for all bins b, the weighted sum 3680 (weights->Run(i)) of all objects i assigned to 'b' is less or 3681 equal to 'bounds[b]'. Ownership of the callback is transferred to 3682 the pack constraint. 3683 3684 | 3685 3686 *Overload 3:* 3687 This dimension imposes that for all bins b, the weighted sum 3688 (weights->Run(i, b) of all objects i assigned to 'b' is less or 3689 equal to 'bounds[b]'. Ownership of the callback is transferred to 3690 the pack constraint. 3691 """ 3692 return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args) 3693 3694 def AddWeightedSumEqualVarDimension(self, *args): 3695 r""" 3696 *Overload 1:* 3697 This dimension imposes that for all bins b, the weighted sum 3698 (weights[i]) of all objects i assigned to 'b' is equal to loads[b]. 3699 3700 | 3701 3702 *Overload 2:* 3703 This dimension imposes that for all bins b, the weighted sum 3704 (weights->Run(i, b)) of all objects i assigned to 'b' is equal to 3705 loads[b]. 3706 """ 3707 return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args) 3708 3709 def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity): 3710 r""" 3711 This dimension imposes: 3712 forall b in bins, 3713 sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] 3714 where is_assigned(i, b) is true if and only if item i is assigned 3715 to the bin b. 3716 3717 This can be used to model shapes of items by linking variables of 3718 the same item on parallel dimensions with an allowed assignment 3719 constraint. 3720 """ 3721 return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity) 3722 3723 def AddWeightedSumOfAssignedDimension(self, weights, cost_var): 3724 r""" 3725 This dimension enforces that cost_var == sum of weights[i] for 3726 all objects 'i' assigned to a bin. 3727 """ 3728 return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var) 3729 3730 def AddCountUsedBinDimension(self, count_var): 3731 r""" 3732 This dimension links 'count_var' to the actual number of bins used in the 3733 pack. 3734 """ 3735 return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var) 3736 3737 def AddCountAssignedItemsDimension(self, count_var): 3738 r""" 3739 This dimension links 'count_var' to the actual number of items 3740 assigned to a bin in the pack. 3741 """ 3742 return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var) 3743 3744 def Post(self): 3745 return _pywrapcp.Pack_Post(self) 3746 3747 def InitialPropagateWrapper(self): 3748 return _pywrapcp.Pack_InitialPropagateWrapper(self) 3749 3750 def DebugString(self): 3751 return _pywrapcp.Pack_DebugString(self)
A constraint is the main modeling object. It provides two methods:
- Post() is responsible for creating the demons and attaching them to immediate demons().
- InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
def
AddWeightedSumLessOrEqualConstantDimension(self, *args):
3665 def AddWeightedSumLessOrEqualConstantDimension(self, *args): 3666 r""" 3667 *Overload 1:* 3668 Dimensions are additional constraints than can restrict what is 3669 possible with the pack constraint. It can be used to set capacity 3670 limits, to count objects per bin, to compute unassigned 3671 penalties... 3672 This dimension imposes that for all bins b, the weighted sum 3673 (weights[i]) of all objects i assigned to 'b' is less or equal 3674 'bounds[b]'. 3675 3676 | 3677 3678 *Overload 2:* 3679 This dimension imposes that for all bins b, the weighted sum 3680 (weights->Run(i)) of all objects i assigned to 'b' is less or 3681 equal to 'bounds[b]'. Ownership of the callback is transferred to 3682 the pack constraint. 3683 3684 | 3685 3686 *Overload 3:* 3687 This dimension imposes that for all bins b, the weighted sum 3688 (weights->Run(i, b) of all objects i assigned to 'b' is less or 3689 equal to 'bounds[b]'. Ownership of the callback is transferred to 3690 the pack constraint. 3691 """ 3692 return _pywrapcp.Pack_AddWeightedSumLessOrEqualConstantDimension(self, *args)
Overload 1: Dimensions are additional constraints than can restrict what is possible with the pack constraint. It can be used to set capacity limits, to count objects per bin, to compute unassigned penalties... This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is less or equal 'bounds[b]'.
|
Overload 2: This dimension imposes that for all bins b, the weighted sum (weights->Run(i)) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
|
Overload 3: This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b) of all objects i assigned to 'b' is less or equal to 'bounds[b]'. Ownership of the callback is transferred to the pack constraint.
def
AddWeightedSumEqualVarDimension(self, *args):
3694 def AddWeightedSumEqualVarDimension(self, *args): 3695 r""" 3696 *Overload 1:* 3697 This dimension imposes that for all bins b, the weighted sum 3698 (weights[i]) of all objects i assigned to 'b' is equal to loads[b]. 3699 3700 | 3701 3702 *Overload 2:* 3703 This dimension imposes that for all bins b, the weighted sum 3704 (weights->Run(i, b)) of all objects i assigned to 'b' is equal to 3705 loads[b]. 3706 """ 3707 return _pywrapcp.Pack_AddWeightedSumEqualVarDimension(self, *args)
Overload 1: This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
|
Overload 2: This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i assigned to 'b' is equal to loads[b].
def
AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity):
3709 def AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity): 3710 r""" 3711 This dimension imposes: 3712 forall b in bins, 3713 sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] 3714 where is_assigned(i, b) is true if and only if item i is assigned 3715 to the bin b. 3716 3717 This can be used to model shapes of items by linking variables of 3718 the same item on parallel dimensions with an allowed assignment 3719 constraint. 3720 """ 3721 return _pywrapcp.Pack_AddSumVariableWeightsLessOrEqualConstantDimension(self, usage, capacity)
This dimension imposes: forall b in bins, sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] where is_assigned(i, b) is true if and only if item i is assigned to the bin b.
This can be used to model shapes of items by linking variables of the same item on parallel dimensions with an allowed assignment constraint.
def
AddWeightedSumOfAssignedDimension(self, weights, cost_var):
3723 def AddWeightedSumOfAssignedDimension(self, weights, cost_var): 3724 r""" 3725 This dimension enforces that cost_var == sum of weights[i] for 3726 all objects 'i' assigned to a bin. 3727 """ 3728 return _pywrapcp.Pack_AddWeightedSumOfAssignedDimension(self, weights, cost_var)
This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin.
def
AddCountUsedBinDimension(self, count_var):
3730 def AddCountUsedBinDimension(self, count_var): 3731 r""" 3732 This dimension links 'count_var' to the actual number of bins used in the 3733 pack. 3734 """ 3735 return _pywrapcp.Pack_AddCountUsedBinDimension(self, count_var)
This dimension links 'count_var' to the actual number of bins used in the pack.
def
AddCountAssignedItemsDimension(self, count_var):
3737 def AddCountAssignedItemsDimension(self, count_var): 3738 r""" 3739 This dimension links 'count_var' to the actual number of items 3740 assigned to a bin in the pack. 3741 """ 3742 return _pywrapcp.Pack_AddCountAssignedItemsDimension(self, count_var)
This dimension links 'count_var' to the actual number of items assigned to a bin in the pack.
def
Post(self):
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
3755class DisjunctiveConstraint(Constraint): 3756 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3757 3758 def __init__(self, *args, **kwargs): 3759 raise AttributeError("No constructor defined - class is abstract") 3760 __repr__ = _swig_repr 3761 3762 def SequenceVar(self): 3763 r""" Creates a sequence variable from the constraint.""" 3764 return _pywrapcp.DisjunctiveConstraint_SequenceVar(self) 3765 3766 def SetTransitionTime(self, transition_time): 3767 r""" 3768 Add a transition time between intervals. It forces the distance between 3769 the end of interval a and start of interval b that follows it to be at 3770 least transition_time(a, b). This function must always return 3771 a positive or null value. 3772 """ 3773 return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time) 3774 3775 def TransitionTime(self, before_index, after_index): 3776 return _pywrapcp.DisjunctiveConstraint_TransitionTime(self, before_index, after_index)
A constraint is the main modeling object. It provides two methods:
- Post() is responsible for creating the demons and attaching them to immediate demons().
- InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
def
SequenceVar(self):
3762 def SequenceVar(self): 3763 r""" Creates a sequence variable from the constraint.""" 3764 return _pywrapcp.DisjunctiveConstraint_SequenceVar(self)
Creates a sequence variable from the constraint.
def
SetTransitionTime(self, transition_time):
3766 def SetTransitionTime(self, transition_time): 3767 r""" 3768 Add a transition time between intervals. It forces the distance between 3769 the end of interval a and start of interval b that follows it to be at 3770 least transition_time(a, b). This function must always return 3771 a positive or null value. 3772 """ 3773 return _pywrapcp.DisjunctiveConstraint_SetTransitionTime(self, transition_time)
Add a transition time between intervals. It forces the distance between the end of interval a and start of interval b that follows it to be at least transition_time(a, b). This function must always return a positive or null value.
Inherited Members
class
RevInteger:
3780class RevInteger(object): 3781 r""" 3782 This class adds reversibility to a POD type. 3783 It contains the stamp optimization. i.e. the SaveValue call is done 3784 only once per node of the search tree. Please note that actual 3785 stamps always starts at 1, thus an initial value of 0 will always 3786 trigger the first SaveValue. 3787 """ 3788 3789 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3790 __repr__ = _swig_repr 3791 3792 def __init__(self, val): 3793 _pywrapcp.RevInteger_swiginit(self, _pywrapcp.new_RevInteger(val)) 3794 3795 def Value(self): 3796 return _pywrapcp.RevInteger_Value(self) 3797 3798 def SetValue(self, s, val): 3799 return _pywrapcp.RevInteger_SetValue(self, s, val) 3800 __swig_destroy__ = _pywrapcp.delete_RevInteger
This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue.
3804class NumericalRevInteger(RevInteger): 3805 r""" Subclass of Rev<T> which adds numerical operations.""" 3806 3807 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3808 __repr__ = _swig_repr 3809 3810 def __init__(self, val): 3811 _pywrapcp.NumericalRevInteger_swiginit(self, _pywrapcp.new_NumericalRevInteger(val)) 3812 3813 def Add(self, s, to_add): 3814 return _pywrapcp.NumericalRevInteger_Add(self, s, to_add) 3815 3816 def Incr(self, s): 3817 return _pywrapcp.NumericalRevInteger_Incr(self, s) 3818 3819 def Decr(self, s): 3820 return _pywrapcp.NumericalRevInteger_Decr(self, s) 3821 __swig_destroy__ = _pywrapcp.delete_NumericalRevInteger
Subclass of Rev
Inherited Members
class
RevBool:
3825class RevBool(object): 3826 r""" 3827 This class adds reversibility to a POD type. 3828 It contains the stamp optimization. i.e. the SaveValue call is done 3829 only once per node of the search tree. Please note that actual 3830 stamps always starts at 1, thus an initial value of 0 will always 3831 trigger the first SaveValue. 3832 """ 3833 3834 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3835 __repr__ = _swig_repr 3836 3837 def __init__(self, val): 3838 _pywrapcp.RevBool_swiginit(self, _pywrapcp.new_RevBool(val)) 3839 3840 def Value(self): 3841 return _pywrapcp.RevBool_Value(self) 3842 3843 def SetValue(self, s, val): 3844 return _pywrapcp.RevBool_SetValue(self, s, val) 3845 __swig_destroy__ = _pywrapcp.delete_RevBool
This class adds reversibility to a POD type. It contains the stamp optimization. i.e. the SaveValue call is done only once per node of the search tree. Please note that actual stamps always starts at 1, thus an initial value of 0 will always trigger the first SaveValue.
class
IntVarContainer:
3849class IntVarContainer(object): 3850 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3851 3852 def __init__(self, *args, **kwargs): 3853 raise AttributeError("No constructor defined") 3854 __repr__ = _swig_repr 3855 3856 def Contains(self, var): 3857 return _pywrapcp.IntVarContainer_Contains(self, var) 3858 3859 def Element(self, index): 3860 return _pywrapcp.IntVarContainer_Element(self, index) 3861 3862 def Size(self): 3863 return _pywrapcp.IntVarContainer_Size(self) 3864 3865 def Store(self): 3866 return _pywrapcp.IntVarContainer_Store(self) 3867 3868 def Restore(self): 3869 return _pywrapcp.IntVarContainer_Restore(self) 3870 3871 def __eq__(self, container): 3872 r""" 3873 Returns true if this and 'container' both represent the same V* -> E map. 3874 Runs in linear time; requires that the == operator on the type E is well 3875 defined. 3876 """ 3877 return _pywrapcp.IntVarContainer___eq__(self, container) 3878 3879 def __ne__(self, container): 3880 return _pywrapcp.IntVarContainer___ne__(self, container) 3881 __swig_destroy__ = _pywrapcp.delete_IntVarContainer
class
IntervalVarContainer:
3885class IntervalVarContainer(object): 3886 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3887 3888 def __init__(self, *args, **kwargs): 3889 raise AttributeError("No constructor defined") 3890 __repr__ = _swig_repr 3891 3892 def Contains(self, var): 3893 return _pywrapcp.IntervalVarContainer_Contains(self, var) 3894 3895 def Element(self, index): 3896 return _pywrapcp.IntervalVarContainer_Element(self, index) 3897 3898 def Size(self): 3899 return _pywrapcp.IntervalVarContainer_Size(self) 3900 3901 def Store(self): 3902 return _pywrapcp.IntervalVarContainer_Store(self) 3903 3904 def Restore(self): 3905 return _pywrapcp.IntervalVarContainer_Restore(self) 3906 3907 def __eq__(self, container): 3908 r""" 3909 Returns true if this and 'container' both represent the same V* -> E map. 3910 Runs in linear time; requires that the == operator on the type E is well 3911 defined. 3912 """ 3913 return _pywrapcp.IntervalVarContainer___eq__(self, container) 3914 3915 def __ne__(self, container): 3916 return _pywrapcp.IntervalVarContainer___ne__(self, container) 3917 __swig_destroy__ = _pywrapcp.delete_IntervalVarContainer
class
SequenceVarContainer:
3921class SequenceVarContainer(object): 3922 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3923 3924 def __init__(self, *args, **kwargs): 3925 raise AttributeError("No constructor defined") 3926 __repr__ = _swig_repr 3927 3928 def Contains(self, var): 3929 return _pywrapcp.SequenceVarContainer_Contains(self, var) 3930 3931 def Element(self, index): 3932 return _pywrapcp.SequenceVarContainer_Element(self, index) 3933 3934 def Size(self): 3935 return _pywrapcp.SequenceVarContainer_Size(self) 3936 3937 def Store(self): 3938 return _pywrapcp.SequenceVarContainer_Store(self) 3939 3940 def Restore(self): 3941 return _pywrapcp.SequenceVarContainer_Restore(self) 3942 3943 def __eq__(self, container): 3944 r""" 3945 Returns true if this and 'container' both represent the same V* -> E map. 3946 Runs in linear time; requires that the == operator on the type E is well 3947 defined. 3948 """ 3949 return _pywrapcp.SequenceVarContainer___eq__(self, container) 3950 3951 def __ne__(self, container): 3952 return _pywrapcp.SequenceVarContainer___ne__(self, container) 3953 __swig_destroy__ = _pywrapcp.delete_SequenceVarContainer
3957class LocalSearchOperator(BaseObject): 3958 r""" 3959 The base class for all local search operators. 3960 3961 A local search operator is an object that defines the neighborhood of a 3962 solution. In other words, a neighborhood is the set of solutions which can 3963 be reached from a given solution using an operator. 3964 3965 The behavior of the LocalSearchOperator class is similar to iterators. 3966 The operator is synchronized with an assignment (gives the 3967 current values of the variables); this is done in the Start() method. 3968 3969 Then one can iterate over the neighbors using the MakeNextNeighbor method. 3970 This method returns an assignment which represents the incremental changes 3971 to the current solution. It also returns a second assignment representing 3972 the changes to the last solution defined by the neighborhood operator; this 3973 assignment is empty if the neighborhood operator cannot track this 3974 information. 3975 """ 3976 3977 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 3978 3979 def __init__(self, *args, **kwargs): 3980 raise AttributeError("No constructor defined - class is abstract") 3981 __repr__ = _swig_repr 3982 3983 def NextNeighbor(self, delta, deltadelta): 3984 return _pywrapcp.LocalSearchOperator_NextNeighbor(self, delta, deltadelta) 3985 3986 def Start(self, assignment): 3987 return _pywrapcp.LocalSearchOperator_Start(self, assignment) 3988 def __disown__(self): 3989 self.this.disown() 3990 _pywrapcp.disown_LocalSearchOperator(self) 3991 return weakref.proxy(self)
The base class for all local search operators.
A local search operator is an object that defines the neighborhood of a solution. In other words, a neighborhood is the set of solutions which can be reached from a given solution using an operator.
The behavior of the LocalSearchOperator class is similar to iterators. The operator is synchronized with an assignment (gives the current values of the variables); this is done in the Start() method.
Then one can iterate over the neighbors using the MakeNextNeighbor method. This method returns an assignment which represents the incremental changes to the current solution. It also returns a second assignment representing the changes to the last solution defined by the neighborhood operator; this assignment is empty if the neighborhood operator cannot track this information.
Inherited Members
3995class IntVarLocalSearchOperator(LocalSearchOperator): 3996 r""" 3997 Specialization of LocalSearchOperator built from an array of IntVars 3998 which specifies the scope of the operator. 3999 This class also takes care of storing current variable values in Start(), 4000 keeps track of changes done by the operator and builds the delta. 4001 The Deactivate() method can be used to perform Large Neighborhood Search. 4002 """ 4003 4004 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4005 __repr__ = _swig_repr 4006 4007 def __init__(self, vars, keep_inverse_values=False): 4008 if self.__class__ == IntVarLocalSearchOperator: 4009 _self = None 4010 else: 4011 _self = self 4012 _pywrapcp.IntVarLocalSearchOperator_swiginit(self, _pywrapcp.new_IntVarLocalSearchOperator(_self, vars, keep_inverse_values)) 4013 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchOperator 4014 4015 def Start(self, assignment): 4016 r""" 4017 This method should not be overridden. Override OnStart() instead which is 4018 called before exiting this method. 4019 """ 4020 return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment) 4021 4022 def IsIncremental(self): 4023 return _pywrapcp.IntVarLocalSearchOperator_IsIncremental(self) 4024 4025 def Size(self): 4026 return _pywrapcp.IntVarLocalSearchOperator_Size(self) 4027 4028 def Value(self, index): 4029 r""" 4030 Returns the value in the current assignment of the variable of given 4031 index. 4032 """ 4033 return _pywrapcp.IntVarLocalSearchOperator_Value(self, index) 4034 4035 def Var(self, index): 4036 r""" Returns the variable of given index.""" 4037 return _pywrapcp.IntVarLocalSearchOperator_Var(self, index) 4038 4039 def OldValue(self, index): 4040 return _pywrapcp.IntVarLocalSearchOperator_OldValue(self, index) 4041 4042 def PrevValue(self, index): 4043 return _pywrapcp.IntVarLocalSearchOperator_PrevValue(self, index) 4044 4045 def SetValue(self, index, value): 4046 return _pywrapcp.IntVarLocalSearchOperator_SetValue(self, index, value) 4047 4048 def Activated(self, index): 4049 return _pywrapcp.IntVarLocalSearchOperator_Activated(self, index) 4050 4051 def Activate(self, index): 4052 return _pywrapcp.IntVarLocalSearchOperator_Activate(self, index) 4053 4054 def Deactivate(self, index): 4055 return _pywrapcp.IntVarLocalSearchOperator_Deactivate(self, index) 4056 4057 def AddVars(self, vars): 4058 return _pywrapcp.IntVarLocalSearchOperator_AddVars(self, vars) 4059 4060 def OnStart(self): 4061 r""" 4062 Called by Start() after synchronizing the operator with the current 4063 assignment. Should be overridden instead of Start() to avoid calling 4064 IntVarLocalSearchOperator::Start explicitly. 4065 """ 4066 return _pywrapcp.IntVarLocalSearchOperator_OnStart(self) 4067 4068 def NextNeighbor(self, delta, deltadelta): 4069 r""" 4070 OnStart() should really be protected, but then SWIG doesn't see it. So we 4071 make it public, but only subclasses should access to it (to override it). 4072 Redefines MakeNextNeighbor to export a simpler interface. The calls to 4073 ApplyChanges() and RevertChanges() are factored in this method, hiding 4074 both delta and deltadelta from subclasses which only need to override 4075 MakeOneNeighbor(). 4076 Therefore this method should not be overridden. Override MakeOneNeighbor() 4077 instead. 4078 """ 4079 return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta) 4080 4081 def OneNeighbor(self): 4082 r""" 4083 Creates a new neighbor. It returns false when the neighborhood is 4084 completely explored. 4085 MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. 4086 """ 4087 return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self) 4088 def __disown__(self): 4089 self.this.disown() 4090 _pywrapcp.disown_IntVarLocalSearchOperator(self) 4091 return weakref.proxy(self)
Specialization of LocalSearchOperator built from an array of IntVars which specifies the scope of the operator. This class also takes care of storing current variable values in Start(), keeps track of changes done by the operator and builds the delta. The Deactivate() method can be used to perform Large Neighborhood Search.
def
Start(self, assignment):
4015 def Start(self, assignment): 4016 r""" 4017 This method should not be overridden. Override OnStart() instead which is 4018 called before exiting this method. 4019 """ 4020 return _pywrapcp.IntVarLocalSearchOperator_Start(self, assignment)
This method should not be overridden. Override OnStart() instead which is called before exiting this method.
def
Value(self, index):
4028 def Value(self, index): 4029 r""" 4030 Returns the value in the current assignment of the variable of given 4031 index. 4032 """ 4033 return _pywrapcp.IntVarLocalSearchOperator_Value(self, index)
Returns the value in the current assignment of the variable of given index.
def
Var(self, index):
4035 def Var(self, index): 4036 r""" Returns the variable of given index.""" 4037 return _pywrapcp.IntVarLocalSearchOperator_Var(self, index)
Returns the variable of given index.
def
OnStart(self):
4060 def OnStart(self): 4061 r""" 4062 Called by Start() after synchronizing the operator with the current 4063 assignment. Should be overridden instead of Start() to avoid calling 4064 IntVarLocalSearchOperator::Start explicitly. 4065 """ 4066 return _pywrapcp.IntVarLocalSearchOperator_OnStart(self)
Called by Start() after synchronizing the operator with the current assignment. Should be overridden instead of Start() to avoid calling IntVarLocalSearchOperator::Start explicitly.
def
NextNeighbor(self, delta, deltadelta):
4068 def NextNeighbor(self, delta, deltadelta): 4069 r""" 4070 OnStart() should really be protected, but then SWIG doesn't see it. So we 4071 make it public, but only subclasses should access to it (to override it). 4072 Redefines MakeNextNeighbor to export a simpler interface. The calls to 4073 ApplyChanges() and RevertChanges() are factored in this method, hiding 4074 both delta and deltadelta from subclasses which only need to override 4075 MakeOneNeighbor(). 4076 Therefore this method should not be overridden. Override MakeOneNeighbor() 4077 instead. 4078 """ 4079 return _pywrapcp.IntVarLocalSearchOperator_NextNeighbor(self, delta, deltadelta)
OnStart() should really be protected, but then SWIG doesn't see it. So we make it public, but only subclasses should access to it (to override it). Redefines MakeNextNeighbor to export a simpler interface. The calls to ApplyChanges() and RevertChanges() are factored in this method, hiding both delta and deltadelta from subclasses which only need to override MakeOneNeighbor(). Therefore this method should not be overridden. Override MakeOneNeighbor() instead.
def
OneNeighbor(self):
4081 def OneNeighbor(self): 4082 r""" 4083 Creates a new neighbor. It returns false when the neighborhood is 4084 completely explored. 4085 MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator. 4086 """ 4087 return _pywrapcp.IntVarLocalSearchOperator_OneNeighbor(self)
Creates a new neighbor. It returns false when the neighborhood is completely explored. MakeNextNeighbor() in a subclass of IntVarLocalSearchOperator.
Inherited Members
4095class BaseLns(IntVarLocalSearchOperator): 4096 r""" 4097 This is the base class for building an Lns operator. An Lns fragment is a 4098 collection of variables which will be relaxed. Fragments are built with 4099 NextFragment(), which returns false if there are no more fragments to build. 4100 Optionally one can override InitFragments, which is called from 4101 LocalSearchOperator::Start to initialize fragment data. 4102 4103 Here's a sample relaxing one variable at a time: 4104 4105 class OneVarLns : public BaseLns { 4106 public: 4107 OneVarLns(const std::vector<IntVar*>& vars) : BaseLns(vars), index_(0) {} 4108 virtual ~OneVarLns() {} 4109 virtual void InitFragments() { index_ = 0; } 4110 virtual bool NextFragment() { 4111 const int size = Size(); 4112 if (index_ < size) { 4113 AppendToFragment(index_); 4114 ++index_; 4115 return true; 4116 } else { 4117 return false; 4118 } 4119 } 4120 4121 private: 4122 int index_; 4123 }; 4124 """ 4125 4126 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4127 __repr__ = _swig_repr 4128 4129 def __init__(self, vars): 4130 if self.__class__ == BaseLns: 4131 _self = None 4132 else: 4133 _self = self 4134 _pywrapcp.BaseLns_swiginit(self, _pywrapcp.new_BaseLns(_self, vars)) 4135 __swig_destroy__ = _pywrapcp.delete_BaseLns 4136 4137 def InitFragments(self): 4138 return _pywrapcp.BaseLns_InitFragments(self) 4139 4140 def NextFragment(self): 4141 return _pywrapcp.BaseLns_NextFragment(self) 4142 4143 def AppendToFragment(self, index): 4144 return _pywrapcp.BaseLns_AppendToFragment(self, index) 4145 4146 def FragmentSize(self): 4147 return _pywrapcp.BaseLns_FragmentSize(self) 4148 4149 def __getitem__(self, index): 4150 return _pywrapcp.BaseLns___getitem__(self, index) 4151 4152 def __len__(self): 4153 return _pywrapcp.BaseLns___len__(self) 4154 def __disown__(self): 4155 self.this.disown() 4156 _pywrapcp.disown_BaseLns(self) 4157 return weakref.proxy(self)
This is the base class for building an Lns operator. An Lns fragment is a collection of variables which will be relaxed. Fragments are built with NextFragment(), which returns false if there are no more fragments to build. Optionally one can override InitFragments, which is called from LocalSearchOperator::Start to initialize fragment data.
Here's a sample relaxing one variable at a time:
class OneVarLns : public BaseLns {
public:
OneVarLns(const std::vector
private: int index_; };
4161class ChangeValue(IntVarLocalSearchOperator): 4162 r""" 4163 Defines operators which change the value of variables; 4164 each neighbor corresponds to *one* modified variable. 4165 Sub-classes have to define ModifyValue which determines what the new 4166 variable value is going to be (given the current value and the variable). 4167 """ 4168 4169 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4170 __repr__ = _swig_repr 4171 4172 def __init__(self, vars): 4173 if self.__class__ == ChangeValue: 4174 _self = None 4175 else: 4176 _self = self 4177 _pywrapcp.ChangeValue_swiginit(self, _pywrapcp.new_ChangeValue(_self, vars)) 4178 __swig_destroy__ = _pywrapcp.delete_ChangeValue 4179 4180 def ModifyValue(self, index, value): 4181 return _pywrapcp.ChangeValue_ModifyValue(self, index, value) 4182 4183 def OneNeighbor(self): 4184 r""" This method should not be overridden. Override ModifyValue() instead.""" 4185 return _pywrapcp.ChangeValue_OneNeighbor(self) 4186 def __disown__(self): 4187 self.this.disown() 4188 _pywrapcp.disown_ChangeValue(self) 4189 return weakref.proxy(self)
Defines operators which change the value of variables; each neighbor corresponds to one modified variable. Sub-classes have to define ModifyValue which determines what the new variable value is going to be (given the current value and the variable).
4193class PathOperator(IntVarLocalSearchOperator): 4194 r""" 4195 Base class of the local search operators dedicated to path modifications 4196 (a path is a set of nodes linked together by arcs). 4197 This family of neighborhoods supposes they are handling next variables 4198 representing the arcs (var[i] represents the node immediately after i on 4199 a path). 4200 Several services are provided: 4201 - arc manipulators (SetNext(), ReverseChain(), MoveChain()) 4202 - path inspectors (Next(), Prev(), IsPathEnd()) 4203 - path iterators: operators need a given number of nodes to define a 4204 neighbor; this class provides the iteration on a given number of (base) 4205 nodes which can be used to define a neighbor (through the BaseNode method) 4206 Subclasses only need to override MakeNeighbor to create neighbors using 4207 the services above (no direct manipulation of assignments). 4208 """ 4209 4210 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4211 4212 def __init__(self, *args, **kwargs): 4213 raise AttributeError("No constructor defined - class is abstract") 4214 __repr__ = _swig_repr 4215 4216 def Neighbor(self): 4217 return _pywrapcp.PathOperator_Neighbor(self)
Base class of the local search operators dedicated to path modifications (a path is a set of nodes linked together by arcs). This family of neighborhoods supposes they are handling next variables representing the arcs (var[i] represents the node immediately after i on a path). Several services are provided:
- arc manipulators (SetNext(), ReverseChain(), MoveChain())
- path inspectors (Next(), Prev(), IsPathEnd())
- path iterators: operators need a given number of nodes to define a neighbor; this class provides the iteration on a given number of (base) nodes which can be used to define a neighbor (through the BaseNode method) Subclasses only need to override MakeNeighbor to create neighbors using the services above (no direct manipulation of assignments).
4221class LocalSearchFilter(BaseObject): 4222 r""" 4223 Classes to which this template function can be applied to as of 04/2014. 4224 Usage: LocalSearchOperator* op = MakeLocalSearchOperator<Relocate>(...); 4225 class TwoOpt; 4226 class Relocate; 4227 class Exchange; 4228 class Cross; 4229 class MakeActiveOperator; 4230 class MakeInactiveOperator; 4231 class MakeChainInactiveOperator; 4232 class SwapActiveOperator; 4233 class ExtendedSwapActiveOperator; 4234 class MakeActiveAndRelocate; 4235 class RelocateAndMakeActiveOperator; 4236 class RelocateAndMakeInactiveOperator; 4237 Local Search Filters are used for fast neighbor pruning. 4238 Filtering a move is done in several phases: 4239 - in the Relax phase, filters determine which parts of their internals 4240 will be changed by the candidate, and modify intermediary State 4241 - in the Accept phase, filters check that the candidate is feasible, 4242 - if the Accept phase succeeds, the solver may decide to trigger a 4243 Synchronize phase that makes filters change their internal representation 4244 to the last candidate, 4245 - otherwise (Accept fails or the solver does not want to synchronize), 4246 a Revert phase makes filters erase any intermediary State generated by the 4247 Relax and Accept phases. 4248 A given filter has phases called with the following pattern: 4249 (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. 4250 Filters's Revert() is always called in the reverse order their Accept() was 4251 called, to allow late filters to use state done/undone by early filters' 4252 Accept()/Revert(). 4253 """ 4254 4255 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4256 4257 def __init__(self, *args, **kwargs): 4258 raise AttributeError("No constructor defined - class is abstract") 4259 __repr__ = _swig_repr 4260 4261 def Accept(self, delta, deltadelta, objective_min, objective_max): 4262 r""" 4263 Accepts a "delta" given the assignment with which the filter has been 4264 synchronized; the delta holds the variables which have been modified and 4265 their new value. 4266 If the filter represents a part of the global objective, its contribution 4267 must be between objective_min and objective_max. 4268 Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, 4269 for the assignment (a,1), (b,0), the delta (b,1) will be rejected 4270 but the delta (a,0) will be accepted. 4271 TODO(user): Remove arguments when there are no more need for those. 4272 """ 4273 return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max) 4274 4275 def IsIncremental(self): 4276 return _pywrapcp.LocalSearchFilter_IsIncremental(self) 4277 4278 def Synchronize(self, assignment, delta): 4279 r""" 4280 Synchronizes the filter with the current solution, delta being the 4281 difference with the solution passed to the previous call to Synchronize() 4282 or IncrementalSynchronize(). 'delta' can be used to incrementally 4283 synchronizing the filter with the new solution by only considering the 4284 changes in delta. 4285 """ 4286 return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta) 4287 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilter
Classes to which this template function can be applied to as of 04/2014.
Usage: LocalSearchOperator* op = MakeLocalSearchOperator
- in the Relax phase, filters determine which parts of their internals will be changed by the candidate, and modify intermediary State
- in the Accept phase, filters check that the candidate is feasible,
- if the Accept phase succeeds, the solver may decide to trigger a Synchronize phase that makes filters change their internal representation to the last candidate,
- otherwise (Accept fails or the solver does not want to synchronize), a Revert phase makes filters erase any intermediary State generated by the Relax and Accept phases. A given filter has phases called with the following pattern: (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. Filters's Revert() is always called in the reverse order their Accept() was called, to allow late filters to use state done/undone by early filters' Accept()/Revert().
def
Accept(self, delta, deltadelta, objective_min, objective_max):
4261 def Accept(self, delta, deltadelta, objective_min, objective_max): 4262 r""" 4263 Accepts a "delta" given the assignment with which the filter has been 4264 synchronized; the delta holds the variables which have been modified and 4265 their new value. 4266 If the filter represents a part of the global objective, its contribution 4267 must be between objective_min and objective_max. 4268 Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, 4269 for the assignment (a,1), (b,0), the delta (b,1) will be rejected 4270 but the delta (a,0) will be accepted. 4271 TODO(user): Remove arguments when there are no more need for those. 4272 """ 4273 return _pywrapcp.LocalSearchFilter_Accept(self, delta, deltadelta, objective_min, objective_max)
Accepts a "delta" given the assignment with which the filter has been synchronized; the delta holds the variables which have been modified and their new value. If the filter represents a part of the global objective, its contribution must be between objective_min and objective_max. Sample: supposing one wants to maintain a[0,1] + b[0,1] <= 1, for the assignment (a,1), (b,0), the delta (b,1) will be rejected but the delta (a,0) will be accepted. TODO(user): Remove arguments when there are no more need for those.
def
Synchronize(self, assignment, delta):
4278 def Synchronize(self, assignment, delta): 4279 r""" 4280 Synchronizes the filter with the current solution, delta being the 4281 difference with the solution passed to the previous call to Synchronize() 4282 or IncrementalSynchronize(). 'delta' can be used to incrementally 4283 synchronizing the filter with the new solution by only considering the 4284 changes in delta. 4285 """ 4286 return _pywrapcp.LocalSearchFilter_Synchronize(self, assignment, delta)
Synchronizes the filter with the current solution, delta being the difference with the solution passed to the previous call to Synchronize() or IncrementalSynchronize(). 'delta' can be used to incrementally synchronizing the filter with the new solution by only considering the changes in delta.
Inherited Members
4291class LocalSearchFilterManager(BaseObject): 4292 r""" 4293 Filter manager: when a move is made, filters are executed to decide whether 4294 the solution is feasible and compute parts of the new cost. This class 4295 schedules filter execution and composes costs as a sum. 4296 """ 4297 4298 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4299 __repr__ = _swig_repr 4300 4301 def DebugString(self): 4302 return _pywrapcp.LocalSearchFilterManager_DebugString(self) 4303 4304 def __init__(self, *args): 4305 _pywrapcp.LocalSearchFilterManager_swiginit(self, _pywrapcp.new_LocalSearchFilterManager(*args)) 4306 4307 def Accept(self, monitor, delta, deltadelta, objective_min, objective_max): 4308 r""" 4309 Returns true iff all filters return true, and the sum of their accepted 4310 objectives is between objective_min and objective_max. 4311 The monitor has its Begin/EndFiltering events triggered. 4312 """ 4313 return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max) 4314 4315 def Synchronize(self, assignment, delta): 4316 r""" Synchronizes all filters to assignment.""" 4317 return _pywrapcp.LocalSearchFilterManager_Synchronize(self, assignment, delta) 4318 __swig_destroy__ = _pywrapcp.delete_LocalSearchFilterManager
Filter manager: when a move is made, filters are executed to decide whether the solution is feasible and compute parts of the new cost. This class schedules filter execution and composes costs as a sum.
def
Accept(self, monitor, delta, deltadelta, objective_min, objective_max):
4307 def Accept(self, monitor, delta, deltadelta, objective_min, objective_max): 4308 r""" 4309 Returns true iff all filters return true, and the sum of their accepted 4310 objectives is between objective_min and objective_max. 4311 The monitor has its Begin/EndFiltering events triggered. 4312 """ 4313 return _pywrapcp.LocalSearchFilterManager_Accept(self, monitor, delta, deltadelta, objective_min, objective_max)
Returns true iff all filters return true, and the sum of their accepted objectives is between objective_min and objective_max. The monitor has its Begin/EndFiltering events triggered.
4322class IntVarLocalSearchFilter(LocalSearchFilter): 4323 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4324 __repr__ = _swig_repr 4325 4326 def __init__(self, vars): 4327 if self.__class__ == IntVarLocalSearchFilter: 4328 _self = None 4329 else: 4330 _self = self 4331 _pywrapcp.IntVarLocalSearchFilter_swiginit(self, _pywrapcp.new_IntVarLocalSearchFilter(_self, vars)) 4332 __swig_destroy__ = _pywrapcp.delete_IntVarLocalSearchFilter 4333 4334 def Synchronize(self, assignment, delta): 4335 r""" 4336 This method should not be overridden. Override OnSynchronize() instead 4337 which is called before exiting this method. 4338 """ 4339 return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta) 4340 4341 def Size(self): 4342 return _pywrapcp.IntVarLocalSearchFilter_Size(self) 4343 4344 def Value(self, index): 4345 return _pywrapcp.IntVarLocalSearchFilter_Value(self, index) 4346 4347 def IndexFromVar(self, var): 4348 return _pywrapcp.IntVarLocalSearchFilter_IndexFromVar(self, var) 4349 def __disown__(self): 4350 self.this.disown() 4351 _pywrapcp.disown_IntVarLocalSearchFilter(self) 4352 return weakref.proxy(self)
Classes to which this template function can be applied to as of 04/2014.
Usage: LocalSearchOperator* op = MakeLocalSearchOperator
- in the Relax phase, filters determine which parts of their internals will be changed by the candidate, and modify intermediary State
- in the Accept phase, filters check that the candidate is feasible,
- if the Accept phase succeeds, the solver may decide to trigger a Synchronize phase that makes filters change their internal representation to the last candidate,
- otherwise (Accept fails or the solver does not want to synchronize), a Revert phase makes filters erase any intermediary State generated by the Relax and Accept phases. A given filter has phases called with the following pattern: (Relax.Accept.Synchronize | Relax.Accept.Revert | Relax.Revert)*. Filters's Revert() is always called in the reverse order their Accept() was called, to allow late filters to use state done/undone by early filters' Accept()/Revert().
def
Synchronize(self, assignment, delta):
4334 def Synchronize(self, assignment, delta): 4335 r""" 4336 This method should not be overridden. Override OnSynchronize() instead 4337 which is called before exiting this method. 4338 """ 4339 return _pywrapcp.IntVarLocalSearchFilter_Synchronize(self, assignment, delta)
This method should not be overridden. Override OnSynchronize() instead which is called before exiting this method.
Inherited Members
4356class BooleanVar(IntVar): 4357 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4358 4359 def __init__(self, *args, **kwargs): 4360 raise AttributeError("No constructor defined - class is abstract") 4361 __repr__ = _swig_repr 4362 4363 def Min(self): 4364 return _pywrapcp.BooleanVar_Min(self) 4365 4366 def SetMin(self, m): 4367 return _pywrapcp.BooleanVar_SetMin(self, m) 4368 4369 def Max(self): 4370 return _pywrapcp.BooleanVar_Max(self) 4371 4372 def SetMax(self, m): 4373 return _pywrapcp.BooleanVar_SetMax(self, m) 4374 4375 def SetRange(self, mi, ma): 4376 return _pywrapcp.BooleanVar_SetRange(self, mi, ma) 4377 4378 def Bound(self): 4379 return _pywrapcp.BooleanVar_Bound(self) 4380 4381 def Value(self): 4382 return _pywrapcp.BooleanVar_Value(self) 4383 4384 def RemoveValue(self, v): 4385 return _pywrapcp.BooleanVar_RemoveValue(self, v) 4386 4387 def RemoveInterval(self, l, u): 4388 return _pywrapcp.BooleanVar_RemoveInterval(self, l, u) 4389 4390 def WhenBound(self, d): 4391 return _pywrapcp.BooleanVar_WhenBound(self, d) 4392 4393 def WhenRange(self, d): 4394 return _pywrapcp.BooleanVar_WhenRange(self, d) 4395 4396 def WhenDomain(self, d): 4397 return _pywrapcp.BooleanVar_WhenDomain(self, d) 4398 4399 def Size(self): 4400 return _pywrapcp.BooleanVar_Size(self) 4401 4402 def Contains(self, v): 4403 return _pywrapcp.BooleanVar_Contains(self, v) 4404 4405 def HoleIteratorAux(self, reversible): 4406 return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible) 4407 4408 def DomainIteratorAux(self, reversible): 4409 return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible) 4410 4411 def DebugString(self): 4412 return _pywrapcp.BooleanVar_DebugString(self)
The class IntVar is a subset of IntExpr. In addition to the IntExpr protocol, it offers persistence, removing values from the domains, and a finer model for events.
def
Value(self):
This method returns the value of the variable. This method checks before that the variable is bound.
def
RemoveInterval(self, l, u):
This method removes the interval 'l' .. 'u' from the domain of the variable. It assumes that 'l' <= 'u'.
def
WhenBound(self, d):
Overload 1: This method attaches a demon that will be awakened when the variable is bound.
|
Overload 2: This method attaches a closure that will be awakened when the variable is bound.
def
WhenRange(self, d):
Overload 1: Attach a demon that will watch the min or the max of the expression.
|
Overload 2: Attach a demon that will watch the min or the max of the expression.
def
WhenDomain(self, d):
Overload 1: This method attaches a demon that will watch any domain modification of the domain of the variable.
|
Overload 2: This method attaches a closure that will watch any domain modification of the domain of the variable.
def
HoleIteratorAux(self, reversible):
4405 def HoleIteratorAux(self, reversible): 4406 return _pywrapcp.BooleanVar_HoleIteratorAux(self, reversible)
Creates a hole iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.
def
DomainIteratorAux(self, reversible):
4408 def DomainIteratorAux(self, reversible): 4409 return _pywrapcp.BooleanVar_DomainIteratorAux(self, reversible)
Creates a domain iterator. When 'reversible' is false, the returned object is created on the normal C++ heap and the solver does NOT take ownership of the object.
4417class PyDecision(Decision): 4418 4419 def __init__(self): 4420 Decision.__init__(self) 4421 4422 def ApplyWrapper(self, solver): 4423 try: 4424 self.Apply(solver) 4425 except Exception as e: 4426 if 'CP Solver fail' in str(e): 4427 solver.ShouldFail() 4428 else: 4429 raise 4430 4431 def RefuteWrapper(self, solver): 4432 try: 4433 self.Refute(solver) 4434 except Exception as e: 4435 if 'CP Solver fail' in str(e): 4436 solver.ShouldFail() 4437 else: 4438 raise 4439 4440 def DebugString(self): 4441 return "PyDecision"
A Decision represents a choice point in the search tree. The two main methods are Apply() to go left, or Refute() to go right.
def
ApplyWrapper(self, solver):
4422 def ApplyWrapper(self, solver): 4423 try: 4424 self.Apply(solver) 4425 except Exception as e: 4426 if 'CP Solver fail' in str(e): 4427 solver.ShouldFail() 4428 else: 4429 raise
Apply will be called first when the decision is executed.
4444class PyDecisionBuilder(DecisionBuilder): 4445 4446 def __init__(self): 4447 DecisionBuilder.__init__(self) 4448 4449 def NextWrapper(self, solver): 4450 try: 4451 return self.Next(solver) 4452 except Exception as e: 4453 if 'CP Solver fail' in str(e): 4454 return solver.FailDecision() 4455 else: 4456 raise 4457 4458 def DebugString(self): 4459 return "PyDecisionBuilder"
A DecisionBuilder is responsible for creating the search tree. The important method is Next(), which returns the next decision to execute.
def
NextWrapper(self, solver):
4449 def NextWrapper(self, solver): 4450 try: 4451 return self.Next(solver) 4452 except Exception as e: 4453 if 'CP Solver fail' in str(e): 4454 return solver.FailDecision() 4455 else: 4456 raise
This is the main method of the decision builder class. It must return a decision (an instance of the class Decision). If it returns nullptr, this means that the decision builder has finished its work.
Inherited Members
4462class PyDemon(Demon): 4463 4464 def RunWrapper(self, solver): 4465 try: 4466 self.Run(solver) 4467 except Exception as e: 4468 if 'CP Solver fail' in str(e): 4469 solver.ShouldFail() 4470 else: 4471 raise 4472 4473 def DebugString(self): 4474 return "PyDemon"
A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications.
There are two methods:
- Run() is the actual method called when the demon is processed.
- priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately.
4477class PyConstraintDemon(PyDemon): 4478 4479 def __init__(self, ct, method, delayed, *args): 4480 PyDemon.__init__(self) 4481 self.__constraint = ct 4482 self.__method = method 4483 self.__delayed = delayed 4484 self.__args = args 4485 4486 def Run(self, solver): 4487 self.__method(self.__constraint, *self.__args) 4488 4489 def Priority(self): 4490 return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY 4491 4492 def DebugString(self): 4493 return 'PyConstraintDemon'
A Demon is the base element of a propagation queue. It is the main object responsible for implementing the actual propagation of the constraint and pruning the inconsistent values in the domains of the variables. The main concept is that demons are listeners that are attached to the variables and listen to their modifications.
There are two methods:
- Run() is the actual method called when the demon is processed.
- priority() returns its priority. Standard priorities are slow, normal or fast. "immediate" is reserved for variables and is treated separately.
PyConstraintDemon(ct, method, delayed, *args)
4479 def __init__(self, ct, method, delayed, *args): 4480 PyDemon.__init__(self) 4481 self.__constraint = ct 4482 self.__method = method 4483 self.__delayed = delayed 4484 self.__args = args
This indicates the priority of a demon. Immediate demons are treated separately and corresponds to variables.
def
Priority(self):
4489 def Priority(self): 4490 return Solver.DELAYED_PRIORITY if self.__delayed else Solver.NORMAL_PRIORITY
This method returns the priority of the demon. Usually a demon is fast, slow or normal. Immediate demons are reserved for internal use to maintain variables.
Inherited Members
4496class PyConstraint(Constraint): 4497 4498 def __init__(self, solver): 4499 Constraint.__init__(self, solver) 4500 self.__demons = [] 4501 4502 def Demon(self, method, *args): 4503 demon = PyConstraintDemon(self, method, False, *args) 4504 self.__demons.append(demon) 4505 return demon 4506 4507 def DelayedDemon(self, method, *args): 4508 demon = PyConstraintDemon(self, method, True, *args) 4509 self.__demons.append(demon) 4510 return demon 4511 4512 def InitialPropagateDemon(self): 4513 return self.solver().ConstraintInitialPropagateCallback(self) 4514 4515 def DelayedInitialPropagateDemon(self): 4516 return self.solver().DelayedConstraintInitialPropagateCallback(self) 4517 4518 def InitialPropagateWrapper(self): 4519 try: 4520 self.InitialPropagate() 4521 except Exception as e: 4522 if 'CP Solver fail' in str(e): 4523 self.solver().ShouldFail() 4524 else: 4525 raise 4526 4527 def DebugString(self): 4528 return "PyConstraint"
A constraint is the main modeling object. It provides two methods:
- Post() is responsible for creating the demons and attaching them to immediate demons().
- InitialPropagate() is called once just after Post and performs the initial propagation. The subsequent propagations will be performed by the demons Posted during the post() method.
def
InitialPropagateWrapper(self):
4518 def InitialPropagateWrapper(self): 4519 try: 4520 self.InitialPropagate() 4521 except Exception as e: 4522 if 'CP Solver fail' in str(e): 4523 self.solver().ShouldFail() 4524 else: 4525 raise
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
class
RoutingIndexManager:
4532class RoutingIndexManager(object): 4533 r""" 4534 Manager for any NodeIndex <-> variable index conversion. The routing solver 4535 uses variable indices internally and through its API. These variable indices 4536 are tricky to manage directly because one Node can correspond to a multitude 4537 of variables, depending on the number of times they appear in the model, and 4538 if they're used as start and/or end points. This class aims to simplify 4539 variable index usage, allowing users to use NodeIndex instead. 4540 4541 Usage: 4542 4543 .. code-block:: c++ 4544 4545 auto starts_ends = ...; /// These are NodeIndex. 4546 RoutingIndexManager manager(10, 4, starts_ends); // 10 nodes, 4 vehicles. 4547 RoutingModel model(manager); 4548 4549 Then, use 'manager.NodeToIndex(node)' whenever model requires a variable 4550 index. 4551 4552 Note: the mapping between node indices and variables indices is subject to 4553 change so no assumption should be made on it. The only guarantee is that 4554 indices range between 0 and n-1, where n = number of vehicles * 2 (for start 4555 and end nodes) + number of non-start or end nodes. 4556 """ 4557 4558 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4559 __repr__ = _swig_repr 4560 4561 def __init__(self, *args): 4562 _pywrapcp.RoutingIndexManager_swiginit(self, _pywrapcp.new_RoutingIndexManager(*args)) 4563 4564 def GetNumberOfNodes(self): 4565 return _pywrapcp.RoutingIndexManager_GetNumberOfNodes(self) 4566 4567 def GetNumberOfVehicles(self): 4568 return _pywrapcp.RoutingIndexManager_GetNumberOfVehicles(self) 4569 4570 def GetNumberOfIndices(self): 4571 return _pywrapcp.RoutingIndexManager_GetNumberOfIndices(self) 4572 4573 def GetStartIndex(self, vehicle): 4574 return _pywrapcp.RoutingIndexManager_GetStartIndex(self, vehicle) 4575 4576 def GetEndIndex(self, vehicle): 4577 return _pywrapcp.RoutingIndexManager_GetEndIndex(self, vehicle) 4578 4579 def NodeToIndex(self, node): 4580 return _pywrapcp.RoutingIndexManager_NodeToIndex(self, node) 4581 4582 def IndexToNode(self, index): 4583 return _pywrapcp.RoutingIndexManager_IndexToNode(self, index) 4584 __swig_destroy__ = _pywrapcp.delete_RoutingIndexManager
Manager for any NodeIndex <-> variable index conversion. The routing solver uses variable indices internally and through its API. These variable indices are tricky to manage directly because one Node can correspond to a multitude of variables, depending on the number of times they appear in the model, and if they're used as start and/or end points. This class aims to simplify variable index usage, allowing users to use NodeIndex instead.
Usage:
.. code-block:: c++
auto starts_ends = ...; /// These are NodeIndex. RoutingIndexManager manager(10, 4, starts_ends); // 10 nodes, 4 vehicles. RoutingModel model(manager);
Then, use 'manager.NodeToIndex(node)' whenever model requires a variable index.
Note: the mapping between node indices and variables indices is subject to change so no assumption should be made on it. The only guarantee is that indices range between 0 and n-1, where n = number of vehicles * 2 (for start and end nodes) + number of non-start or end nodes.
def
DefaultRoutingModelParameters():
def
DefaultRoutingSearchParameters():
def
FindErrorInRoutingSearchParameters(search_parameters):
4595def FindErrorInRoutingSearchParameters(search_parameters): 4596 r""" 4597 Returns an empty std::string if the routing search parameters are valid, and 4598 a non-empty, human readable error description if they're not. 4599 """ 4600 return _pywrapcp.FindErrorInRoutingSearchParameters(search_parameters)
Returns an empty std::string if the routing search parameters are valid, and a non-empty, human readable error description if they're not.
BOOL_UNSPECIFIED =
0
BOOL_FALSE =
2
BOOL_TRUE =
3
class
FirstSolutionStrategy:
4604class FirstSolutionStrategy(object): 4605 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4606 __repr__ = _swig_repr 4607 4608 def __init__(self): 4609 _pywrapcp.FirstSolutionStrategy_swiginit(self, _pywrapcp.new_FirstSolutionStrategy()) 4610 __swig_destroy__ = _pywrapcp.delete_FirstSolutionStrategy
class
LocalSearchMetaheuristic:
4614class LocalSearchMetaheuristic(object): 4615 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4616 __repr__ = _swig_repr 4617 4618 def __init__(self): 4619 _pywrapcp.LocalSearchMetaheuristic_swiginit(self, _pywrapcp.new_LocalSearchMetaheuristic()) 4620 __swig_destroy__ = _pywrapcp.delete_LocalSearchMetaheuristic
class
PathsMetadata:
4624class PathsMetadata(object): 4625 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4626 __repr__ = _swig_repr 4627 4628 def __init__(self, manager): 4629 _pywrapcp.PathsMetadata_swiginit(self, _pywrapcp.new_PathsMetadata(manager)) 4630 4631 def IsStart(self, node): 4632 return _pywrapcp.PathsMetadata_IsStart(self, node) 4633 4634 def IsEnd(self, node): 4635 return _pywrapcp.PathsMetadata_IsEnd(self, node) 4636 4637 def GetPath(self, start_or_end_node): 4638 return _pywrapcp.PathsMetadata_GetPath(self, start_or_end_node) 4639 4640 def NumPaths(self): 4641 return _pywrapcp.PathsMetadata_NumPaths(self) 4642 4643 def Paths(self): 4644 return _pywrapcp.PathsMetadata_Paths(self) 4645 4646 def Starts(self): 4647 return _pywrapcp.PathsMetadata_Starts(self) 4648 4649 def Ends(self): 4650 return _pywrapcp.PathsMetadata_Ends(self) 4651 __swig_destroy__ = _pywrapcp.delete_PathsMetadata
class
RoutingModel:
4655class RoutingModel(object): 4656 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 4657 __repr__ = _swig_repr 4658 ROUTING_NOT_SOLVED = _pywrapcp.RoutingModel_ROUTING_NOT_SOLVED 4659 r""" Problem not solved yet (before calling RoutingModel::Solve()).""" 4660 ROUTING_SUCCESS = _pywrapcp.RoutingModel_ROUTING_SUCCESS 4661 r""" Problem solved successfully after calling RoutingModel::Solve().""" 4662 ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED = _pywrapcp.RoutingModel_ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED 4663 r""" 4664 Problem solved successfully after calling RoutingModel::Solve(), except 4665 that a local optimum has not been reached. Leaving more time would allow 4666 improving the solution. 4667 """ 4668 ROUTING_FAIL = _pywrapcp.RoutingModel_ROUTING_FAIL 4669 r""" No solution found to the problem after calling RoutingModel::Solve().""" 4670 ROUTING_FAIL_TIMEOUT = _pywrapcp.RoutingModel_ROUTING_FAIL_TIMEOUT 4671 r""" Time limit reached before finding a solution with RoutingModel::Solve().""" 4672 ROUTING_INVALID = _pywrapcp.RoutingModel_ROUTING_INVALID 4673 r""" Model, model parameters or flags are not valid.""" 4674 ROUTING_INFEASIBLE = _pywrapcp.RoutingModel_ROUTING_INFEASIBLE 4675 r""" Problem proven to be infeasible.""" 4676 PICKUP_AND_DELIVERY_NO_ORDER = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_NO_ORDER 4677 r""" Any precedence is accepted.""" 4678 PICKUP_AND_DELIVERY_LIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_LIFO 4679 r""" Deliveries must be performed in reverse order of pickups.""" 4680 PICKUP_AND_DELIVERY_FIFO = _pywrapcp.RoutingModel_PICKUP_AND_DELIVERY_FIFO 4681 r""" Deliveries must be performed in the same order as pickups.""" 4682 4683 def __init__(self, *args): 4684 _pywrapcp.RoutingModel_swiginit(self, _pywrapcp.new_RoutingModel(*args)) 4685 __swig_destroy__ = _pywrapcp.delete_RoutingModel 4686 kTransitEvaluatorSignUnknown = _pywrapcp.RoutingModel_kTransitEvaluatorSignUnknown 4687 kTransitEvaluatorSignPositiveOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignPositiveOrZero 4688 kTransitEvaluatorSignNegativeOrZero = _pywrapcp.RoutingModel_kTransitEvaluatorSignNegativeOrZero 4689 4690 def RegisterUnaryTransitVector(self, values): 4691 r""" 4692 Registers 'callback' and returns its index. 4693 The sign parameter allows to notify the solver that the callback only 4694 return values of the given sign. This can help the solver, but passing 4695 an incorrect sign may crash in non-opt compilation mode, and yield 4696 incorrect results in opt. 4697 """ 4698 return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values) 4699 4700 def RegisterUnaryTransitCallback(self, *args): 4701 return _pywrapcp.RoutingModel_RegisterUnaryTransitCallback(self, *args) 4702 4703 def RegisterTransitMatrix(self, values): 4704 return _pywrapcp.RoutingModel_RegisterTransitMatrix(self, values) 4705 4706 def RegisterTransitCallback(self, *args): 4707 return _pywrapcp.RoutingModel_RegisterTransitCallback(self, *args) 4708 4709 def TransitCallback(self, callback_index): 4710 return _pywrapcp.RoutingModel_TransitCallback(self, callback_index) 4711 4712 def UnaryTransitCallbackOrNull(self, callback_index): 4713 return _pywrapcp.RoutingModel_UnaryTransitCallbackOrNull(self, callback_index) 4714 4715 def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name): 4716 r""" 4717 Model creation 4718 Methods to add dimensions to routes; dimensions represent quantities 4719 accumulated at nodes along the routes. They represent quantities such as 4720 weights or volumes carried along the route, or distance or times. 4721 Quantities at a node are represented by "cumul" variables and the increase 4722 or decrease of quantities between nodes are represented by "transit" 4723 variables. These variables are linked as follows: 4724 if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) 4725 where slack is a positive slack variable (can represent waiting times for 4726 a time dimension). 4727 Setting the value of fix_start_cumul_to_zero to true will force the 4728 "cumul" variable of the start node of all vehicles to be equal to 0. 4729 Creates a dimension where the transit variable is constrained to be 4730 equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the 4731 slack variable and 'capacity' is the upper bound of the cumul variables. 4732 'name' is the name used to reference the dimension; this name is used to 4733 get cumul and transit variables from the routing model. 4734 Returns false if a dimension with the same name has already been created 4735 (and doesn't create the new dimension). 4736 Takes ownership of the callback 'evaluator'. 4737 """ 4738 return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name) 4739 4740 def AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name): 4741 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransits(self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name) 4742 4743 def AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4744 return _pywrapcp.RoutingModel_AddDimensionWithVehicleCapacity(self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4745 4746 def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4747 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name) 4748 4749 def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name): 4750 r""" 4751 Creates a dimension where the transit variable is constrained to be 4752 equal to 'value'; 'capacity' is the upper bound of the cumul variables. 4753 'name' is the name used to reference the dimension; this name is used to 4754 get cumul and transit variables from the routing model. 4755 Returns a pair consisting of an index to the registered unary transit 4756 callback and a bool denoting whether the dimension has been created. 4757 It is false if a dimension with the same name has already been created 4758 (and doesn't create the new dimension but still register a new callback). 4759 """ 4760 return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name) 4761 4762 def AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name): 4763 return _pywrapcp.RoutingModel_AddConstantDimension(self, value, capacity, fix_start_cumul_to_zero, name) 4764 4765 def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4766 r""" 4767 Creates a dimension where the transit variable is constrained to be 4768 equal to 'values[i]' for node i; 'capacity' is the upper bound of 4769 the cumul variables. 'name' is the name used to reference the dimension; 4770 this name is used to get cumul and transit variables from the routing 4771 model. 4772 Returns a pair consisting of an index to the registered unary transit 4773 callback and a bool denoting whether the dimension has been created. 4774 It is false if a dimension with the same name has already been created 4775 (and doesn't create the new dimension but still register a new callback). 4776 """ 4777 return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4778 4779 def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4780 r""" 4781 Creates a dimension where the transit variable is constrained to be 4782 equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of 4783 the cumul variables. 'name' is the name used to reference the dimension; 4784 this name is used to get cumul and transit variables from the routing 4785 model. 4786 Returns a pair consisting of an index to the registered transit callback 4787 and a bool denoting whether the dimension has been created. 4788 It is false if a dimension with the same name has already been created 4789 (and doesn't create the new dimension but still register a new callback). 4790 """ 4791 return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name) 4792 4793 def GetAllDimensionNames(self): 4794 r""" Outputs the names of all dimensions added to the routing engine.""" 4795 return _pywrapcp.RoutingModel_GetAllDimensionNames(self) 4796 4797 def GetDimensions(self): 4798 r""" Returns all dimensions of the model.""" 4799 return _pywrapcp.RoutingModel_GetDimensions(self) 4800 4801 def GetDimensionsWithSoftOrSpanCosts(self): 4802 r""" Returns dimensions with soft or vehicle span costs.""" 4803 return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self) 4804 4805 def GetDimensionsWithGlobalCumulOptimizers(self): 4806 r""" Returns the dimensions which have [global|local]_dimension_optimizers_.""" 4807 return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self) 4808 4809 def GetDimensionsWithLocalCumulOptimizers(self): 4810 return _pywrapcp.RoutingModel_GetDimensionsWithLocalCumulOptimizers(self) 4811 4812 def HasGlobalCumulOptimizer(self, dimension): 4813 r""" Returns whether the given dimension has global/local cumul optimizers.""" 4814 return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension) 4815 4816 def HasLocalCumulOptimizer(self, dimension): 4817 return _pywrapcp.RoutingModel_HasLocalCumulOptimizer(self, dimension) 4818 4819 def GetMutableGlobalCumulLPOptimizer(self, dimension): 4820 r""" 4821 Returns the global/local dimension cumul optimizer for a given dimension, 4822 or nullptr if there is none. 4823 """ 4824 return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension) 4825 4826 def GetMutableGlobalCumulMPOptimizer(self, dimension): 4827 return _pywrapcp.RoutingModel_GetMutableGlobalCumulMPOptimizer(self, dimension) 4828 4829 def GetMutableLocalCumulLPOptimizer(self, dimension): 4830 return _pywrapcp.RoutingModel_GetMutableLocalCumulLPOptimizer(self, dimension) 4831 4832 def GetMutableLocalCumulMPOptimizer(self, dimension): 4833 return _pywrapcp.RoutingModel_GetMutableLocalCumulMPOptimizer(self, dimension) 4834 4835 def HasDimension(self, dimension_name): 4836 r""" Returns true if a dimension exists for a given dimension name.""" 4837 return _pywrapcp.RoutingModel_HasDimension(self, dimension_name) 4838 4839 def GetDimensionOrDie(self, dimension_name): 4840 r""" Returns a dimension from its name. Dies if the dimension does not exist.""" 4841 return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name) 4842 4843 def GetMutableDimension(self, dimension_name): 4844 r""" 4845 Returns a dimension from its name. Returns nullptr if the dimension does 4846 not exist. 4847 """ 4848 return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name) 4849 4850 def SetPrimaryConstrainedDimension(self, dimension_name): 4851 r""" 4852 Set the given dimension as "primary constrained". As of August 2013, this 4853 is only used by ArcIsMoreConstrainedThanArc(). 4854 "dimension" must be the name of an existing dimension, or be empty, in 4855 which case there will not be a primary dimension after this call. 4856 """ 4857 return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name) 4858 4859 def GetPrimaryConstrainedDimension(self): 4860 r""" Get the primary constrained dimension, or an empty string if it is unset.""" 4861 return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self) 4862 4863 def AddResourceGroup(self): 4864 r""" 4865 Adds a resource group to the routing model. Returns its index in 4866 resource_groups_. 4867 """ 4868 return _pywrapcp.RoutingModel_AddResourceGroup(self) 4869 4870 def GetResourceGroups(self): 4871 return _pywrapcp.RoutingModel_GetResourceGroups(self) 4872 4873 def GetResourceGroup(self, rg_index): 4874 return _pywrapcp.RoutingModel_GetResourceGroup(self, rg_index) 4875 4876 def GetDimensionResourceGroupIndices(self, dimension): 4877 r""" 4878 Returns the indices of resource groups for this dimension. This method can 4879 only be called after the model has been closed. 4880 """ 4881 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension) 4882 4883 def GetDimensionResourceGroupIndex(self, dimension): 4884 r""" 4885 Returns the index of the resource group attached to the dimension. 4886 DCHECKS that there's exactly one resource group for this dimension. 4887 """ 4888 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension) 4889 4890 def AddDisjunction(self, *args): 4891 r""" 4892 Adds a disjunction constraint on the indices: exactly 'max_cardinality' of 4893 the indices are active. Start and end indices of any vehicle cannot be 4894 part of a disjunction. 4895 4896 If a penalty is given, at most 'max_cardinality' of the indices can be 4897 active, and if less are active, 'penalty' is payed per inactive index. 4898 This is equivalent to adding the constraint: 4899 p + Sum(i)active[i] == max_cardinality 4900 where p is an integer variable, and the following cost to the cost 4901 function: 4902 p * penalty. 4903 'penalty' must be positive to make the disjunction optional; a negative 4904 penalty will force 'max_cardinality' indices of the disjunction to be 4905 performed, and therefore p == 0. 4906 Note: passing a vector with a single index will model an optional index 4907 with a penalty cost if it is not visited. 4908 """ 4909 return _pywrapcp.RoutingModel_AddDisjunction(self, *args) 4910 4911 def GetDisjunctionIndices(self, index): 4912 r""" Returns the indices of the disjunctions to which an index belongs.""" 4913 return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index) 4914 4915 def GetDisjunctionPenalty(self, index): 4916 r""" Returns the penalty of the node disjunction of index 'index'.""" 4917 return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index) 4918 4919 def GetDisjunctionMaxCardinality(self, index): 4920 r""" 4921 Returns the maximum number of possible active nodes of the node 4922 disjunction of index 'index'. 4923 """ 4924 return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index) 4925 4926 def GetNumberOfDisjunctions(self): 4927 r""" Returns the number of node disjunctions in the model.""" 4928 return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self) 4929 4930 def HasMandatoryDisjunctions(self): 4931 r""" 4932 Returns true if the model contains mandatory disjunctions (ones with 4933 kNoPenalty as penalty). 4934 """ 4935 return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self) 4936 4937 def HasMaxCardinalityConstrainedDisjunctions(self): 4938 r""" 4939 Returns true if the model contains at least one disjunction which is 4940 constrained by its max_cardinality. 4941 """ 4942 return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self) 4943 4944 def GetPerfectBinaryDisjunctions(self): 4945 r""" 4946 Returns the list of all perfect binary disjunctions, as pairs of variable 4947 indices: a disjunction is "perfect" when its variables do not appear in 4948 any other disjunction. Each pair is sorted (lowest variable index first), 4949 and the output vector is also sorted (lowest pairs first). 4950 """ 4951 return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self) 4952 4953 def IgnoreDisjunctionsAlreadyForcedToZero(self): 4954 r""" 4955 SPECIAL: Makes the solver ignore all the disjunctions whose active 4956 variables are all trivially zero (i.e. Max() == 0), by setting their 4957 max_cardinality to 0. 4958 This can be useful when using the BaseBinaryDisjunctionNeighborhood 4959 operators, in the context of arc-based routing. 4960 """ 4961 return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self) 4962 4963 def AddSoftSameVehicleConstraint(self, indices, cost): 4964 r""" 4965 Adds a soft constraint to force a set of variable indices to be on the 4966 same vehicle. If all nodes are not on the same vehicle, each extra vehicle 4967 used adds 'cost' to the cost function. 4968 """ 4969 return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost) 4970 4971 def SetAllowedVehiclesForIndex(self, vehicles, index): 4972 r""" 4973 Sets the vehicles which can visit a given node. If the node is in a 4974 disjunction, this will not prevent it from being unperformed. 4975 Specifying an empty vector of vehicles has no effect (all vehicles 4976 will be allowed to visit the node). 4977 """ 4978 return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index) 4979 4980 def IsVehicleAllowedForIndex(self, vehicle, index): 4981 r""" Returns true if a vehicle is allowed to visit a given node.""" 4982 return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index) 4983 4984 def AddPickupAndDelivery(self, pickup, delivery): 4985 r""" 4986 Notifies that index1 and index2 form a pair of nodes which should belong 4987 to the same route. This methods helps the search find better solutions, 4988 especially in the local search phase. 4989 It should be called each time you have an equality constraint linking 4990 the vehicle variables of two node (including for instance pickup and 4991 delivery problems): 4992 Solver* const solver = routing.solver(); 4993 int64_t index1 = manager.NodeToIndex(node1); 4994 int64_t index2 = manager.NodeToIndex(node2); 4995 solver->AddConstraint(solver->MakeEquality( 4996 routing.VehicleVar(index1), 4997 routing.VehicleVar(index2))); 4998 routing.AddPickupAndDelivery(index1, index2); 4999 """ 5000 return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery) 5001 5002 def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction): 5003 r""" 5004 Same as AddPickupAndDelivery but notifying that the performed node from 5005 the disjunction of index 'pickup_disjunction' is on the same route as the 5006 performed node from the disjunction of index 'delivery_disjunction'. 5007 """ 5008 return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction) 5009 5010 def GetPickupIndexPairs(self, node_index): 5011 r""" 5012 Returns pairs for which the node is a pickup; the first element of each 5013 pair is the index in the pickup and delivery pairs list in which the 5014 pickup appears, the second element is its index in the pickups list. 5015 """ 5016 return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index) 5017 5018 def GetDeliveryIndexPairs(self, node_index): 5019 r""" Same as above for deliveries.""" 5020 return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index) 5021 5022 def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy): 5023 r""" 5024 Sets the Pickup and delivery policy of all vehicles. It is equivalent to 5025 calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles. 5026 """ 5027 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy) 5028 5029 def SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle): 5030 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfVehicle(self, policy, vehicle) 5031 5032 def GetPickupAndDeliveryPolicyOfVehicle(self, vehicle): 5033 return _pywrapcp.RoutingModel_GetPickupAndDeliveryPolicyOfVehicle(self, vehicle) 5034 5035 def GetNumOfSingletonNodes(self): 5036 r""" 5037 Returns the number of non-start/end nodes which do not appear in a 5038 pickup/delivery pair. 5039 """ 5040 return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self) 5041 TYPE_ADDED_TO_VEHICLE = _pywrapcp.RoutingModel_TYPE_ADDED_TO_VEHICLE 5042 r""" When visited, the number of types 'T' on the vehicle increases by one.""" 5043 ADDED_TYPE_REMOVED_FROM_VEHICLE = _pywrapcp.RoutingModel_ADDED_TYPE_REMOVED_FROM_VEHICLE 5044 r""" 5045 When visited, one instance of type 'T' previously added to the route 5046 (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle. 5047 If the type was not previously added to the route or all added instances 5048 have already been removed, this visit has no effect on the types. 5049 """ 5050 TYPE_ON_VEHICLE_UP_TO_VISIT = _pywrapcp.RoutingModel_TYPE_ON_VEHICLE_UP_TO_VISIT 5051 r""" 5052 With the following policy, the visit enforces that type 'T' is 5053 considered on the route from its start until this node is visited. 5054 """ 5055 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED = _pywrapcp.RoutingModel_TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 5056 r""" 5057 The visit doesn't have an impact on the number of types 'T' on the 5058 route, as it's (virtually) added and removed directly. 5059 This policy can be used for visits which are part of an incompatibility 5060 or requirement set without affecting the type count on the route. 5061 """ 5062 5063 def SetVisitType(self, index, type, type_policy): 5064 return _pywrapcp.RoutingModel_SetVisitType(self, index, type, type_policy) 5065 5066 def GetVisitType(self, index): 5067 return _pywrapcp.RoutingModel_GetVisitType(self, index) 5068 5069 def GetSingleNodesOfType(self, type): 5070 return _pywrapcp.RoutingModel_GetSingleNodesOfType(self, type) 5071 5072 def GetPairIndicesOfType(self, type): 5073 return _pywrapcp.RoutingModel_GetPairIndicesOfType(self, type) 5074 5075 def GetVisitTypePolicy(self, index): 5076 return _pywrapcp.RoutingModel_GetVisitTypePolicy(self, index) 5077 5078 def CloseVisitTypes(self): 5079 r""" 5080 This function should be called once all node visit types have been set and 5081 prior to adding any incompatibilities/requirements. 5082 "close" types. 5083 """ 5084 return _pywrapcp.RoutingModel_CloseVisitTypes(self) 5085 5086 def GetNumberOfVisitTypes(self): 5087 return _pywrapcp.RoutingModel_GetNumberOfVisitTypes(self) 5088 5089 def AddHardTypeIncompatibility(self, type1, type2): 5090 r""" 5091 Incompatibilities: 5092 Two nodes with "hard" incompatible types cannot share the same route at 5093 all, while with a "temporal" incompatibility they can't be on the same 5094 route at the same time. 5095 """ 5096 return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2) 5097 5098 def AddTemporalTypeIncompatibility(self, type1, type2): 5099 return _pywrapcp.RoutingModel_AddTemporalTypeIncompatibility(self, type1, type2) 5100 5101 def GetHardTypeIncompatibilitiesOfType(self, type): 5102 r""" Returns visit types incompatible with a given type.""" 5103 return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type) 5104 5105 def GetTemporalTypeIncompatibilitiesOfType(self, type): 5106 return _pywrapcp.RoutingModel_GetTemporalTypeIncompatibilitiesOfType(self, type) 5107 5108 def HasHardTypeIncompatibilities(self): 5109 r""" 5110 Returns true iff any hard (resp. temporal) type incompatibilities have 5111 been added to the model. 5112 """ 5113 return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self) 5114 5115 def HasTemporalTypeIncompatibilities(self): 5116 return _pywrapcp.RoutingModel_HasTemporalTypeIncompatibilities(self) 5117 5118 def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives): 5119 r""" 5120 Requirements: 5121 NOTE: As of 2019-04, cycles in the requirement graph are not supported, 5122 and lead to the dependent nodes being skipped if possible (otherwise 5123 the model is considered infeasible). 5124 The following functions specify that "dependent_type" requires at least 5125 one of the types in "required_type_alternatives". 5126 5127 For same-vehicle requirements, a node of dependent type type_D requires at 5128 least one node of type type_R among the required alternatives on the same 5129 route. 5130 """ 5131 return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives) 5132 5133 def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives): 5134 r""" 5135 If type_D depends on type_R when adding type_D, any node_D of type_D and 5136 VisitTypePolicy TYPE_ADDED_TO_VEHICLE or 5137 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its 5138 vehicle at the time node_D is visited. 5139 """ 5140 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives) 5141 5142 def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives): 5143 r""" 5144 The following requirements apply when visiting dependent nodes that remove 5145 their type from the route, i.e. type_R must be on the vehicle when type_D 5146 of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, 5147 TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is 5148 visited. 5149 """ 5150 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives) 5151 5152 def GetSameVehicleRequiredTypeAlternativesOfType(self, type): 5153 r""" 5154 Returns the set of same-vehicle requirement alternatives for the given 5155 type. 5156 """ 5157 return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type) 5158 5159 def GetRequiredTypeAlternativesWhenAddingType(self, type): 5160 r""" Returns the set of requirement alternatives when adding the given type.""" 5161 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type) 5162 5163 def GetRequiredTypeAlternativesWhenRemovingType(self, type): 5164 r""" Returns the set of requirement alternatives when removing the given type.""" 5165 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type) 5166 5167 def HasSameVehicleTypeRequirements(self): 5168 r""" 5169 Returns true iff any same-route (resp. temporal) type requirements have 5170 been added to the model. 5171 """ 5172 return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self) 5173 5174 def HasTemporalTypeRequirements(self): 5175 return _pywrapcp.RoutingModel_HasTemporalTypeRequirements(self) 5176 5177 def HasTypeRegulations(self): 5178 r""" 5179 Returns true iff the model has any incompatibilities or requirements set 5180 on node types. 5181 """ 5182 return _pywrapcp.RoutingModel_HasTypeRegulations(self) 5183 5184 def UnperformedPenalty(self, var_index): 5185 r""" 5186 Get the "unperformed" penalty of a node. This is only well defined if the 5187 node is only part of a single Disjunction, and that disjunction has a 5188 penalty. For forced active nodes returns max int64_t. In all other cases, 5189 this returns 0. 5190 """ 5191 return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index) 5192 5193 def UnperformedPenaltyOrValue(self, default_value, var_index): 5194 r""" 5195 Same as above except that it returns default_value instead of 0 when 5196 penalty is not well defined (default value is passed as first argument to 5197 simplify the usage of the method in a callback). 5198 """ 5199 return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index) 5200 5201 def GetDepot(self): 5202 r""" 5203 Returns the variable index of the first starting or ending node of all 5204 routes. If all routes start and end at the same node (single depot), this 5205 is the node returned. 5206 """ 5207 return _pywrapcp.RoutingModel_GetDepot(self) 5208 5209 def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles): 5210 r""" 5211 Constrains the maximum number of active vehicles, aka the number of 5212 vehicles which do not have an empty route. For instance, this can be used 5213 to limit the number of routes in the case where there are fewer drivers 5214 than vehicles and that the fleet of vehicle is heterogeneous. 5215 """ 5216 return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles) 5217 5218 def GetMaximumNumberOfActiveVehicles(self): 5219 r""" Returns the maximum number of active vehicles.""" 5220 return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self) 5221 5222 def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index): 5223 r""" 5224 Sets the cost function of the model such that the cost of a segment of a 5225 route between node 'from' and 'to' is evaluator(from, to), whatever the 5226 route or vehicle performing the route. 5227 """ 5228 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index) 5229 5230 def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle): 5231 r""" Sets the cost function for a given vehicle route.""" 5232 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle) 5233 5234 def SetFixedCostOfAllVehicles(self, cost): 5235 r""" 5236 Sets the fixed cost of all vehicle routes. It is equivalent to calling 5237 SetFixedCostOfVehicle on all vehicle routes. 5238 """ 5239 return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost) 5240 5241 def SetFixedCostOfVehicle(self, cost, vehicle): 5242 r""" Sets the fixed cost of one vehicle route.""" 5243 return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle) 5244 5245 def GetFixedCostOfVehicle(self, vehicle): 5246 r""" 5247 Returns the route fixed cost taken into account if the route of the 5248 vehicle is not empty, aka there's at least one node on the route other 5249 than the first and last nodes. 5250 """ 5251 return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle) 5252 5253 def SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle): 5254 return _pywrapcp.RoutingModel_SetPathEnergyCostOfVehicle(self, force, distance, unit_cost, vehicle) 5255 5256 def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor): 5257 r""" 5258 The following methods set the linear and quadratic cost factors of 5259 vehicles (must be positive values). The default value of these parameters 5260 is zero for all vehicles. 5261 5262 When set, the cost_ of the model will contain terms aiming at reducing the 5263 number of vehicles used in the model, by adding the following to the 5264 objective for every vehicle v: 5265 INDICATOR(v used in the model) * 5266 [linear_cost_factor_of_vehicle_[v] 5267 - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] 5268 i.e. for every used vehicle, we add the linear factor as fixed cost, and 5269 subtract the square of the route length multiplied by the quadratic 5270 factor. This second term aims at making the routes as dense as possible. 5271 5272 Sets the linear and quadratic cost factor of all vehicles. 5273 """ 5274 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor) 5275 5276 def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle): 5277 r""" Sets the linear and quadratic cost factor of the given vehicle.""" 5278 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle) 5279 5280 def GetAmortizedLinearCostFactorOfVehicles(self): 5281 return _pywrapcp.RoutingModel_GetAmortizedLinearCostFactorOfVehicles(self) 5282 5283 def GetAmortizedQuadraticCostFactorOfVehicles(self): 5284 return _pywrapcp.RoutingModel_GetAmortizedQuadraticCostFactorOfVehicles(self) 5285 5286 def SetVehicleUsedWhenEmpty(self, is_used, vehicle): 5287 return _pywrapcp.RoutingModel_SetVehicleUsedWhenEmpty(self, is_used, vehicle) 5288 5289 def IsVehicleUsedWhenEmpty(self, vehicle): 5290 return _pywrapcp.RoutingModel_IsVehicleUsedWhenEmpty(self, vehicle) 5291 5292 def SetFirstSolutionEvaluator(self, evaluator): 5293 r""" 5294 Gets/sets the evaluator used during the search. Only relevant when 5295 RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. 5296 Takes ownership of evaluator. 5297 """ 5298 return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator) 5299 5300 def AddLocalSearchOperator(self, ls_operator): 5301 r""" 5302 Adds a local search operator to the set of operators used to solve the 5303 vehicle routing problem. 5304 """ 5305 return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator) 5306 5307 def AddSearchMonitor(self, monitor): 5308 r""" Adds a search monitor to the search used to solve the routing model.""" 5309 return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor) 5310 5311 def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False): 5312 r""" 5313 Adds a callback called each time a solution is found during the search. 5314 This is a shortcut to creating a monitor to call the callback on 5315 AtSolution() and adding it with AddSearchMonitor. 5316 If track_unchecked_neighbors is true, the callback will also be called on 5317 AcceptUncheckedNeighbor() events, which is useful to grab solutions 5318 obtained when solver_parameters.check_solution_period > 1 (aka fastLS). 5319 """ 5320 return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors) 5321 5322 def AddVariableMinimizedByFinalizer(self, var): 5323 r""" 5324 Adds a variable to minimize in the solution finalizer. The solution 5325 finalizer is called each time a solution is found during the search and 5326 allows to instantiate secondary variables (such as dimension cumul 5327 variables). 5328 """ 5329 return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var) 5330 5331 def AddVariableMaximizedByFinalizer(self, var): 5332 r""" 5333 Adds a variable to maximize in the solution finalizer (see above for 5334 information on the solution finalizer). 5335 """ 5336 return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var) 5337 5338 def AddWeightedVariableMinimizedByFinalizer(self, var, cost): 5339 r""" 5340 Adds a variable to minimize in the solution finalizer, with a weighted 5341 priority: the higher the more priority it has. 5342 """ 5343 return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost) 5344 5345 def AddWeightedVariableMaximizedByFinalizer(self, var, cost): 5346 r""" 5347 Adds a variable to maximize in the solution finalizer, with a weighted 5348 priority: the higher the more priority it has. 5349 """ 5350 return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost) 5351 5352 def AddVariableTargetToFinalizer(self, var, target): 5353 r""" 5354 Add a variable to set the closest possible to the target value in the 5355 solution finalizer. 5356 """ 5357 return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target) 5358 5359 def AddWeightedVariableTargetToFinalizer(self, var, target, cost): 5360 r""" 5361 Same as above with a weighted priority: the higher the cost, the more 5362 priority it has to be set close to the target value. 5363 """ 5364 return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost) 5365 5366 def CloseModel(self): 5367 r""" 5368 Closes the current routing model; after this method is called, no 5369 modification to the model can be done, but RoutesToAssignment becomes 5370 available. Note that CloseModel() is automatically called by Solve() and 5371 other methods that produce solution. 5372 This is equivalent to calling 5373 CloseModelWithParameters(DefaultRoutingSearchParameters()). 5374 """ 5375 return _pywrapcp.RoutingModel_CloseModel(self) 5376 5377 def CloseModelWithParameters(self, search_parameters): 5378 r""" 5379 Same as above taking search parameters (as of 10/2015 some the parameters 5380 have to be set when closing the model). 5381 """ 5382 return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters) 5383 5384 def Solve(self, assignment=None): 5385 r""" 5386 Solves the current routing model; closes the current model. 5387 This is equivalent to calling 5388 SolveWithParameters(DefaultRoutingSearchParameters()) 5389 or 5390 SolveFromAssignmentWithParameters(assignment, 5391 DefaultRoutingSearchParameters()). 5392 """ 5393 return _pywrapcp.RoutingModel_Solve(self, assignment) 5394 5395 def SolveWithParameters(self, search_parameters, solutions=None): 5396 r""" 5397 Solves the current routing model with the given parameters. If 'solutions' 5398 is specified, it will contain the k best solutions found during the search 5399 (from worst to best, including the one returned by this method), where k 5400 corresponds to the 'number_of_solutions_to_collect' in 5401 'search_parameters'. Note that the Assignment returned by the method and 5402 the ones in solutions are owned by the underlying solver and should not be 5403 deleted. 5404 """ 5405 return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions) 5406 5407 def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None): 5408 r""" 5409 Same as above, except that if assignment is not null, it will be used as 5410 the initial solution. 5411 """ 5412 return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions) 5413 5414 def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None): 5415 r""" 5416 Same as above but will try all assignments in order as first solutions 5417 until one succeeds. 5418 """ 5419 return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions) 5420 5421 def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment): 5422 r""" 5423 Given a "source_model" and its "source_assignment", resets 5424 "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ 5425 if costs aren't homogeneous across vehicles) of "this" model, with the 5426 values set according to those in "other_assignment". 5427 The objective_element of target_assignment is set to this->cost_. 5428 """ 5429 return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment) 5430 5431 def ComputeLowerBound(self): 5432 r""" 5433 Computes a lower bound to the routing problem solving a linear assignment 5434 problem. The routing model must be closed before calling this method. 5435 Note that problems with node disjunction constraints (including optional 5436 nodes) and non-homogenous costs are not supported (the method returns 0 in 5437 these cases). 5438 """ 5439 return _pywrapcp.RoutingModel_ComputeLowerBound(self) 5440 5441 def status(self): 5442 r""" Returns the current status of the routing model.""" 5443 return _pywrapcp.RoutingModel_status(self) 5444 5445 def enable_deep_serialization(self): 5446 r""" Returns the value of the internal enable_deep_serialization_ parameter.""" 5447 return _pywrapcp.RoutingModel_enable_deep_serialization(self) 5448 5449 def ApplyLocks(self, locks): 5450 r""" 5451 Applies a lock chain to the next search. 'locks' represents an ordered 5452 vector of nodes representing a partial route which will be fixed during 5453 the next search; it will constrain next variables such that: 5454 next[locks[i]] == locks[i+1]. 5455 5456 Returns the next variable at the end of the locked chain; this variable is 5457 not locked. An assignment containing the locks can be obtained by calling 5458 PreAssignment(). 5459 """ 5460 return _pywrapcp.RoutingModel_ApplyLocks(self, locks) 5461 5462 def ApplyLocksToAllVehicles(self, locks, close_routes): 5463 r""" 5464 Applies lock chains to all vehicles to the next search, such that locks[p] 5465 is the lock chain for route p. Returns false if the locks do not contain 5466 valid routes; expects that the routes do not contain the depots, 5467 i.e. there are empty vectors in place of empty routes. 5468 If close_routes is set to true, adds the end nodes to the route of each 5469 vehicle and deactivates other nodes. 5470 An assignment containing the locks can be obtained by calling 5471 PreAssignment(). 5472 """ 5473 return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes) 5474 5475 def PreAssignment(self): 5476 r""" 5477 Returns an assignment used to fix some of the variables of the problem. 5478 In practice, this assignment locks partial routes of the problem. This 5479 can be used in the context of locking the parts of the routes which have 5480 already been driven in online routing problems. 5481 """ 5482 return _pywrapcp.RoutingModel_PreAssignment(self) 5483 5484 def MutablePreAssignment(self): 5485 return _pywrapcp.RoutingModel_MutablePreAssignment(self) 5486 5487 def WriteAssignment(self, file_name): 5488 r""" 5489 Writes the current solution to a file containing an AssignmentProto. 5490 Returns false if the file cannot be opened or if there is no current 5491 solution. 5492 """ 5493 return _pywrapcp.RoutingModel_WriteAssignment(self, file_name) 5494 5495 def ReadAssignment(self, file_name): 5496 r""" 5497 Reads an assignment from a file and returns the current solution. 5498 Returns nullptr if the file cannot be opened or if the assignment is not 5499 valid. 5500 """ 5501 return _pywrapcp.RoutingModel_ReadAssignment(self, file_name) 5502 5503 def RestoreAssignment(self, solution): 5504 r""" 5505 Restores an assignment as a solution in the routing model and returns the 5506 new solution. Returns nullptr if the assignment is not valid. 5507 """ 5508 return _pywrapcp.RoutingModel_RestoreAssignment(self, solution) 5509 5510 def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices): 5511 r""" 5512 Restores the routes as the current solution. Returns nullptr if the 5513 solution cannot be restored (routes do not contain a valid solution). Note 5514 that calling this method will run the solver to assign values to the 5515 dimension variables; this may take considerable amount of time, especially 5516 when using dimensions with slack. 5517 """ 5518 return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices) 5519 5520 def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment): 5521 r""" 5522 Fills an assignment from a specification of the routes of the 5523 vehicles. The routes are specified as lists of variable indices that 5524 appear on the routes of the vehicles. The indices of the outer vector in 5525 'routes' correspond to vehicles IDs, the inner vector contains the 5526 variable indices on the routes for the given vehicle. The inner vectors 5527 must not contain the start and end indices, as these are determined by the 5528 routing model. Sets the value of NextVars in the assignment, adding the 5529 variables to the assignment if necessary. The method does not touch other 5530 variables in the assignment. The method can only be called after the model 5531 is closed. With ignore_inactive_indices set to false, this method will 5532 fail (return nullptr) in case some of the route contain indices that are 5533 deactivated in the model; when set to true, these indices will be 5534 skipped. Returns true if routes were successfully 5535 loaded. However, such assignment still might not be a valid 5536 solution to the routing problem due to more complex constraints; 5537 it is advisible to call solver()->CheckSolution() afterwards. 5538 """ 5539 return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment) 5540 5541 def AssignmentToRoutes(self, assignment, routes): 5542 r""" 5543 Converts the solution in the given assignment to routes for all vehicles. 5544 Expects that assignment contains a valid solution (i.e. routes for all 5545 vehicles end with an end index for that vehicle). 5546 """ 5547 return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes) 5548 5549 def CompactAssignment(self, assignment): 5550 r""" 5551 Converts the solution in the given assignment to routes for all vehicles. 5552 If the returned vector is route_indices, route_indices[i][j] is the index 5553 for jth location visited on route i. Note that contrary to 5554 AssignmentToRoutes, the vectors do include start and end locations. 5555 Returns a compacted version of the given assignment, in which all vehicles 5556 with id lower or equal to some N have non-empty routes, and all vehicles 5557 with id greater than N have empty routes. Does not take ownership of the 5558 returned object. 5559 If found, the cost of the compact assignment is the same as in the 5560 original assignment and it preserves the values of 'active' variables. 5561 Returns nullptr if a compact assignment was not found. 5562 This method only works in homogenous mode, and it only swaps equivalent 5563 vehicles (vehicles with the same start and end nodes). When creating the 5564 compact assignment, the empty plan is replaced by the route assigned to 5565 the compatible vehicle with the highest id. Note that with more complex 5566 constraints on vehicle variables, this method might fail even if a compact 5567 solution exists. 5568 This method changes the vehicle and dimension variables as necessary. 5569 While compacting the solution, only basic checks on vehicle variables are 5570 performed; if one of these checks fails no attempts to repair it are made 5571 (instead, the method returns nullptr). 5572 """ 5573 return _pywrapcp.RoutingModel_CompactAssignment(self, assignment) 5574 5575 def CompactAndCheckAssignment(self, assignment): 5576 r""" 5577 Same as CompactAssignment() but also checks the validity of the final 5578 compact solution; if it is not valid, no attempts to repair it are made 5579 (instead, the method returns nullptr). 5580 """ 5581 return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment) 5582 5583 def AddToAssignment(self, var): 5584 r""" Adds an extra variable to the vehicle routing assignment.""" 5585 return _pywrapcp.RoutingModel_AddToAssignment(self, var) 5586 5587 def AddIntervalToAssignment(self, interval): 5588 return _pywrapcp.RoutingModel_AddIntervalToAssignment(self, interval) 5589 5590 def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None): 5591 r""" 5592 For every dimension in the model with an optimizer in 5593 local/global_dimension_optimizers_, this method tries to pack the cumul 5594 values of the dimension, such that: 5595 - The cumul costs (span costs, soft lower and upper bound costs, etc) are 5596 minimized. 5597 - The cumuls of the ends of the routes are minimized for this given 5598 minimal cumul cost. 5599 - Given these minimal end cumuls, the route start cumuls are maximized. 5600 Returns the assignment resulting from allocating these packed cumuls with 5601 the solver, and nullptr if these cumuls could not be set by the solver. 5602 """ 5603 return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached) 5604 5605 def GetOrCreateNodeNeighborsByCostClass(self, *args): 5606 r""" 5607 *Overload 1:* 5608 Returns neighbors of all nodes for every cost class. The result is cached 5609 and is computed once. The number of neighbors considered is based on a 5610 ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum 5611 of min-neighbors node considered. 5612 5613 | 5614 5615 *Overload 2:* 5616 Returns parameters.num_neighbors neighbors of all nodes for every cost 5617 class. The result is cached and is computed once. 5618 5619 | 5620 5621 *Overload 3:* 5622 Returns parameters.num_neighbors neighbors of all nodes for every cost 5623 class. The result is cached and is computed once. 5624 """ 5625 return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args) 5626 5627 def AddLocalSearchFilter(self, filter): 5628 r""" 5629 Adds a custom local search filter to the list of filters used to speed up 5630 local search by pruning unfeasible variable assignments. 5631 Calling this method after the routing model has been closed (CloseModel() 5632 or Solve() has been called) has no effect. 5633 The routing model does not take ownership of the filter. 5634 """ 5635 return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter) 5636 5637 def Start(self, vehicle): 5638 r""" 5639 Model inspection. 5640 Returns the variable index of the starting node of a vehicle route. 5641 """ 5642 return _pywrapcp.RoutingModel_Start(self, vehicle) 5643 5644 def End(self, vehicle): 5645 r""" Returns the variable index of the ending node of a vehicle route.""" 5646 return _pywrapcp.RoutingModel_End(self, vehicle) 5647 5648 def IsStart(self, index): 5649 r""" Returns true if 'index' represents the first node of a route.""" 5650 return _pywrapcp.RoutingModel_IsStart(self, index) 5651 5652 def IsEnd(self, index): 5653 r""" Returns true if 'index' represents the last node of a route.""" 5654 return _pywrapcp.RoutingModel_IsEnd(self, index) 5655 5656 def VehicleIndex(self, index): 5657 r""" 5658 Returns the vehicle of the given start/end index, and -1 if the given 5659 index is not a vehicle start/end. 5660 """ 5661 return _pywrapcp.RoutingModel_VehicleIndex(self, index) 5662 5663 def Next(self, assignment, index): 5664 r""" 5665 Assignment inspection 5666 Returns the variable index of the node directly after the node 5667 corresponding to 'index' in 'assignment'. 5668 """ 5669 return _pywrapcp.RoutingModel_Next(self, assignment, index) 5670 5671 def IsVehicleUsed(self, assignment, vehicle): 5672 r""" Returns true if the route of 'vehicle' is non empty in 'assignment'.""" 5673 return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle) 5674 5675 def NextVar(self, index): 5676 r""" 5677 Returns the next variable of the node corresponding to index. Note that 5678 NextVar(index) == index is equivalent to ActiveVar(index) == 0. 5679 """ 5680 return _pywrapcp.RoutingModel_NextVar(self, index) 5681 5682 def ActiveVar(self, index): 5683 r""" Returns the active variable of the node corresponding to index.""" 5684 return _pywrapcp.RoutingModel_ActiveVar(self, index) 5685 5686 def ActiveVehicleVar(self, vehicle): 5687 r""" 5688 Returns the active variable of the vehicle. It will be equal to 1 iff the 5689 route of the vehicle is not empty, 0 otherwise. 5690 """ 5691 return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle) 5692 5693 def VehicleRouteConsideredVar(self, vehicle): 5694 r""" 5695 Returns the variable specifying whether or not the given vehicle route is 5696 considered for costs and constraints. It will be equal to 1 iff the route 5697 of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true. 5698 """ 5699 return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle) 5700 5701 def VehicleVar(self, index): 5702 r""" 5703 Returns the vehicle variable of the node corresponding to index. Note that 5704 VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0. 5705 """ 5706 return _pywrapcp.RoutingModel_VehicleVar(self, index) 5707 5708 def ResourceVar(self, vehicle, resource_group): 5709 r""" 5710 Returns the resource variable for the given vehicle index in the given 5711 resource group. If a vehicle doesn't require a resource from the 5712 corresponding resource group, then ResourceVar(v, r_g) == -1. 5713 """ 5714 return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group) 5715 5716 def CostVar(self): 5717 r""" Returns the global cost variable which is being minimized.""" 5718 return _pywrapcp.RoutingModel_CostVar(self) 5719 5720 def GetArcCostForVehicle(self, from_index, to_index, vehicle): 5721 r""" 5722 Returns the cost of the transit arc between two nodes for a given vehicle. 5723 Input are variable indices of node. This returns 0 if vehicle < 0. 5724 """ 5725 return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle) 5726 5727 def CostsAreHomogeneousAcrossVehicles(self): 5728 r""" Whether costs are homogeneous across all vehicles.""" 5729 return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self) 5730 5731 def GetHomogeneousCost(self, from_index, to_index): 5732 r""" 5733 Returns the cost of the segment between two nodes supposing all vehicle 5734 costs are the same (returns the cost for the first vehicle otherwise). 5735 """ 5736 return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index) 5737 5738 def GetArcCostForFirstSolution(self, from_index, to_index): 5739 r""" 5740 Returns the cost of the arc in the context of the first solution strategy. 5741 This is typically a simplification of the actual cost; see the .cc. 5742 """ 5743 return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index) 5744 5745 def GetArcCostForClass(self, from_index, to_index, cost_class_index): 5746 r""" 5747 Returns the cost of the segment between two nodes for a given cost 5748 class. Input are variable indices of nodes and the cost class. 5749 Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the 5750 returned cost won't necessarily be zero: only some of the components 5751 of the cost that depend on the cost class will be omited. See the code 5752 for details. 5753 """ 5754 return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index) 5755 5756 def GetCostClassIndexOfVehicle(self, vehicle): 5757 r""" Get the cost class index of the given vehicle.""" 5758 return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle) 5759 5760 def HasVehicleWithCostClassIndex(self, cost_class_index): 5761 r""" 5762 Returns true iff the model contains a vehicle with the given 5763 cost_class_index. 5764 """ 5765 return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index) 5766 5767 def GetCostClassesCount(self): 5768 r""" Returns the number of different cost classes in the model.""" 5769 return _pywrapcp.RoutingModel_GetCostClassesCount(self) 5770 5771 def GetNonZeroCostClassesCount(self): 5772 r""" Ditto, minus the 'always zero', built-in cost class.""" 5773 return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self) 5774 5775 def GetVehicleClassIndexOfVehicle(self, vehicle): 5776 return _pywrapcp.RoutingModel_GetVehicleClassIndexOfVehicle(self, vehicle) 5777 5778 def GetVehicleOfClass(self, vehicle_class): 5779 r""" 5780 Returns a vehicle of the given vehicle class, and -1 if there are no 5781 vehicles for this class. 5782 """ 5783 return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class) 5784 5785 def GetVehicleClassesCount(self): 5786 r""" Returns the number of different vehicle classes in the model.""" 5787 return _pywrapcp.RoutingModel_GetVehicleClassesCount(self) 5788 5789 def GetSameVehicleIndicesOfIndex(self, node): 5790 r""" Returns variable indices of nodes constrained to be on the same route.""" 5791 return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node) 5792 5793 def GetVehicleTypeContainer(self): 5794 return _pywrapcp.RoutingModel_GetVehicleTypeContainer(self) 5795 5796 def ArcIsMoreConstrainedThanArc(self, _from, to1, to2): 5797 r""" 5798 Returns whether the arc from->to1 is more constrained than from->to2, 5799 taking into account, in order: 5800 - whether the destination node isn't an end node 5801 - whether the destination node is mandatory 5802 - whether the destination node is bound to the same vehicle as the source 5803 - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) 5804 It then breaks ties using, in order: 5805 - the arc cost (taking unperformed penalties into account) 5806 - the size of the vehicle vars of "to1" and "to2" (lowest size wins) 5807 - the value: the lowest value of the indices to1 and to2 wins. 5808 See the .cc for details. 5809 The more constrained arc is typically preferable when building a 5810 first solution. This method is intended to be used as a callback for the 5811 BestValueByComparisonSelector value selector. 5812 Args: 5813 from: the variable index of the source node 5814 to1: the variable index of the first candidate destination node. 5815 to2: the variable index of the second candidate destination node. 5816 """ 5817 return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2) 5818 5819 def DebugOutputAssignment(self, solution_assignment, dimension_to_print): 5820 r""" 5821 Print some debugging information about an assignment, including the 5822 feasible intervals of the CumulVar for dimension "dimension_to_print" 5823 at each step of the routes. 5824 If "dimension_to_print" is omitted, all dimensions will be printed. 5825 """ 5826 return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print) 5827 5828 def solver(self): 5829 r""" 5830 Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair 5831 containing the minimum and maximum of the CumulVar of the jth node on 5832 route i. 5833 - cumul_bounds[i][j].first is the minimum. 5834 - cumul_bounds[i][j].second is the maximum. 5835 Returns the underlying constraint solver. Can be used to add extra 5836 constraints and/or modify search algorithms. 5837 """ 5838 return _pywrapcp.RoutingModel_solver(self) 5839 5840 def CheckLimit(self, *args): 5841 r""" 5842 Returns true if the search limit has been crossed with the given time 5843 offset. 5844 """ 5845 return _pywrapcp.RoutingModel_CheckLimit(self, *args) 5846 5847 def RemainingTime(self): 5848 r""" Returns the time left in the search limit.""" 5849 return _pywrapcp.RoutingModel_RemainingTime(self) 5850 5851 def TimeBuffer(self): 5852 r""" Returns the time buffer to safely return a solution.""" 5853 return _pywrapcp.RoutingModel_TimeBuffer(self) 5854 5855 def nodes(self): 5856 r""" 5857 Sizes and indices 5858 Returns the number of nodes in the model. 5859 """ 5860 return _pywrapcp.RoutingModel_nodes(self) 5861 5862 def vehicles(self): 5863 r""" Returns the number of vehicle routes in the model.""" 5864 return _pywrapcp.RoutingModel_vehicles(self) 5865 5866 def Size(self): 5867 r""" Returns the number of next variables in the model.""" 5868 return _pywrapcp.RoutingModel_Size(self) 5869 5870 def GetNumberOfDecisionsInFirstSolution(self, search_parameters): 5871 r""" 5872 Returns statistics on first solution search, number of decisions sent to 5873 filters, number of decisions rejected by filters. 5874 """ 5875 return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters) 5876 5877 def GetNumberOfRejectsInFirstSolution(self, search_parameters): 5878 return _pywrapcp.RoutingModel_GetNumberOfRejectsInFirstSolution(self, search_parameters) 5879 5880 def GetAutomaticFirstSolutionStrategy(self): 5881 r""" Returns the automatic first solution strategy selected.""" 5882 return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self) 5883 5884 def IsMatchingModel(self): 5885 r""" Returns true if a vehicle/node matching problem is detected.""" 5886 return _pywrapcp.RoutingModel_IsMatchingModel(self) 5887 5888 def AreRoutesInterdependent(self, parameters): 5889 r""" 5890 Returns true if routes are interdependent. This means that any 5891 modification to a route might impact another. 5892 """ 5893 return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters) 5894 5895 def MakeGuidedSlackFinalizer(self, dimension, initializer): 5896 r""" 5897 The next few members are in the public section only for testing purposes. 5898 5899 MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a 5900 dimension using a callback to choose which values to start with. 5901 The finalizer works only when all next variables in the model have 5902 been fixed. It has the following two characteristics: 5903 1. It follows the routes defined by the nexts variables when choosing a 5904 variable to make a decision on. 5905 2. When it comes to choose a value for the slack of node i, the decision 5906 builder first calls the callback with argument i, and supposingly the 5907 returned value is x it creates decisions slack[i] = x, slack[i] = x + 5908 1, slack[i] = x - 1, slack[i] = x + 2, etc. 5909 """ 5910 return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer) 5911 5912 def MakeSelfDependentDimensionFinalizer(self, dimension): 5913 r""" 5914 MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a 5915 self-dependent dimension. It makes an extensive use of the caches of the 5916 state dependent transits. 5917 In detail, MakeSelfDependentDimensionFinalizer returns a composition of a 5918 local search decision builder with a greedy descent operator for the cumul 5919 of the start of each route and a guided slack finalizer. Provided there 5920 are no time windows and the maximum slacks are large enough, once the 5921 cumul of the start of route is fixed, the guided finalizer can find 5922 optimal values of the slacks for the rest of the route in time 5923 proportional to the length of the route. Therefore the composed finalizer 5924 generally works in time O(log(t)*n*m), where t is the latest possible 5925 departute time, n is the number of nodes in the network and m is the 5926 number of vehicles. 5927 """ 5928 return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension) 5929 5930 def GetPathsMetadata(self): 5931 return _pywrapcp.RoutingModel_GetPathsMetadata(self)
ROUTING_PARTIAL_SUCCESS_LOCAL_OPTIMUM_NOT_REACHED =
2
Problem solved successfully after calling RoutingModel::Solve(), except that a local optimum has not been reached. Leaving more time would allow improving the solution.
def
RegisterUnaryTransitVector(self, values):
4690 def RegisterUnaryTransitVector(self, values): 4691 r""" 4692 Registers 'callback' and returns its index. 4693 The sign parameter allows to notify the solver that the callback only 4694 return values of the given sign. This can help the solver, but passing 4695 an incorrect sign may crash in non-opt compilation mode, and yield 4696 incorrect results in opt. 4697 """ 4698 return _pywrapcp.RoutingModel_RegisterUnaryTransitVector(self, values)
Registers 'callback' and returns its index. The sign parameter allows to notify the solver that the callback only return values of the given sign. This can help the solver, but passing an incorrect sign may crash in non-opt compilation mode, and yield incorrect results in opt.
def
AddDimension( self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name):
4715 def AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name): 4716 r""" 4717 Model creation 4718 Methods to add dimensions to routes; dimensions represent quantities 4719 accumulated at nodes along the routes. They represent quantities such as 4720 weights or volumes carried along the route, or distance or times. 4721 Quantities at a node are represented by "cumul" variables and the increase 4722 or decrease of quantities between nodes are represented by "transit" 4723 variables. These variables are linked as follows: 4724 if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) 4725 where slack is a positive slack variable (can represent waiting times for 4726 a time dimension). 4727 Setting the value of fix_start_cumul_to_zero to true will force the 4728 "cumul" variable of the start node of all vehicles to be equal to 0. 4729 Creates a dimension where the transit variable is constrained to be 4730 equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the 4731 slack variable and 'capacity' is the upper bound of the cumul variables. 4732 'name' is the name used to reference the dimension; this name is used to 4733 get cumul and transit variables from the routing model. 4734 Returns false if a dimension with the same name has already been created 4735 (and doesn't create the new dimension). 4736 Takes ownership of the callback 'evaluator'. 4737 """ 4738 return _pywrapcp.RoutingModel_AddDimension(self, evaluator_index, slack_max, capacity, fix_start_cumul_to_zero, name)
Model creation Methods to add dimensions to routes; dimensions represent quantities accumulated at nodes along the routes. They represent quantities such as weights or volumes carried along the route, or distance or times. Quantities at a node are represented by "cumul" variables and the increase or decrease of quantities between nodes are represented by "transit" variables. These variables are linked as follows: if j == next(i), cumul(j) = cumul(i) + transit(i, j) + slack(i) where slack is a positive slack variable (can represent waiting times for a time dimension). Setting the value of fix_start_cumul_to_zero to true will force the "cumul" variable of the start node of all vehicles to be equal to 0. Creates a dimension where the transit variable is constrained to be equal to evaluator(i, next(i)); 'slack_max' is the upper bound of the slack variable and 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns false if a dimension with the same name has already been created (and doesn't create the new dimension). Takes ownership of the callback 'evaluator'.
def
AddDimensionWithVehicleTransits( self, evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name):
def
AddDimensionWithVehicleCapacity( self, evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
def
AddDimensionWithVehicleTransitAndCapacity( self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name):
4746 def AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name): 4747 return _pywrapcp.RoutingModel_AddDimensionWithVehicleTransitAndCapacity(self, evaluator_indices, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name)
def
AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name):
4749 def AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name): 4750 r""" 4751 Creates a dimension where the transit variable is constrained to be 4752 equal to 'value'; 'capacity' is the upper bound of the cumul variables. 4753 'name' is the name used to reference the dimension; this name is used to 4754 get cumul and transit variables from the routing model. 4755 Returns a pair consisting of an index to the registered unary transit 4756 callback and a bool denoting whether the dimension has been created. 4757 It is false if a dimension with the same name has already been created 4758 (and doesn't create the new dimension but still register a new callback). 4759 """ 4760 return _pywrapcp.RoutingModel_AddConstantDimensionWithSlack(self, value, capacity, slack_max, fix_start_cumul_to_zero, name)
Creates a dimension where the transit variable is constrained to be equal to 'value'; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered unary transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).
def
AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4765 def AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4766 r""" 4767 Creates a dimension where the transit variable is constrained to be 4768 equal to 'values[i]' for node i; 'capacity' is the upper bound of 4769 the cumul variables. 'name' is the name used to reference the dimension; 4770 this name is used to get cumul and transit variables from the routing 4771 model. 4772 Returns a pair consisting of an index to the registered unary transit 4773 callback and a bool denoting whether the dimension has been created. 4774 It is false if a dimension with the same name has already been created 4775 (and doesn't create the new dimension but still register a new callback). 4776 """ 4777 return _pywrapcp.RoutingModel_AddVectorDimension(self, values, capacity, fix_start_cumul_to_zero, name)
Creates a dimension where the transit variable is constrained to be equal to 'values[i]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered unary transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).
def
AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name):
4779 def AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name): 4780 r""" 4781 Creates a dimension where the transit variable is constrained to be 4782 equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of 4783 the cumul variables. 'name' is the name used to reference the dimension; 4784 this name is used to get cumul and transit variables from the routing 4785 model. 4786 Returns a pair consisting of an index to the registered transit callback 4787 and a bool denoting whether the dimension has been created. 4788 It is false if a dimension with the same name has already been created 4789 (and doesn't create the new dimension but still register a new callback). 4790 """ 4791 return _pywrapcp.RoutingModel_AddMatrixDimension(self, values, capacity, fix_start_cumul_to_zero, name)
Creates a dimension where the transit variable is constrained to be equal to 'values[i][next(i)]' for node i; 'capacity' is the upper bound of the cumul variables. 'name' is the name used to reference the dimension; this name is used to get cumul and transit variables from the routing model. Returns a pair consisting of an index to the registered transit callback and a bool denoting whether the dimension has been created. It is false if a dimension with the same name has already been created (and doesn't create the new dimension but still register a new callback).
def
GetAllDimensionNames(self):
4793 def GetAllDimensionNames(self): 4794 r""" Outputs the names of all dimensions added to the routing engine.""" 4795 return _pywrapcp.RoutingModel_GetAllDimensionNames(self)
Outputs the names of all dimensions added to the routing engine.
def
GetDimensions(self):
4797 def GetDimensions(self): 4798 r""" Returns all dimensions of the model.""" 4799 return _pywrapcp.RoutingModel_GetDimensions(self)
Returns all dimensions of the model.
def
GetDimensionsWithSoftOrSpanCosts(self):
4801 def GetDimensionsWithSoftOrSpanCosts(self): 4802 r""" Returns dimensions with soft or vehicle span costs.""" 4803 return _pywrapcp.RoutingModel_GetDimensionsWithSoftOrSpanCosts(self)
Returns dimensions with soft or vehicle span costs.
def
GetDimensionsWithGlobalCumulOptimizers(self):
4805 def GetDimensionsWithGlobalCumulOptimizers(self): 4806 r""" Returns the dimensions which have [global|local]_dimension_optimizers_.""" 4807 return _pywrapcp.RoutingModel_GetDimensionsWithGlobalCumulOptimizers(self)
Returns the dimensions which have [global|local]_dimension_optimizers_.
def
HasGlobalCumulOptimizer(self, dimension):
4812 def HasGlobalCumulOptimizer(self, dimension): 4813 r""" Returns whether the given dimension has global/local cumul optimizers.""" 4814 return _pywrapcp.RoutingModel_HasGlobalCumulOptimizer(self, dimension)
Returns whether the given dimension has global/local cumul optimizers.
def
GetMutableGlobalCumulLPOptimizer(self, dimension):
4819 def GetMutableGlobalCumulLPOptimizer(self, dimension): 4820 r""" 4821 Returns the global/local dimension cumul optimizer for a given dimension, 4822 or nullptr if there is none. 4823 """ 4824 return _pywrapcp.RoutingModel_GetMutableGlobalCumulLPOptimizer(self, dimension)
Returns the global/local dimension cumul optimizer for a given dimension, or nullptr if there is none.
def
HasDimension(self, dimension_name):
4835 def HasDimension(self, dimension_name): 4836 r""" Returns true if a dimension exists for a given dimension name.""" 4837 return _pywrapcp.RoutingModel_HasDimension(self, dimension_name)
Returns true if a dimension exists for a given dimension name.
def
GetDimensionOrDie(self, dimension_name):
4839 def GetDimensionOrDie(self, dimension_name): 4840 r""" Returns a dimension from its name. Dies if the dimension does not exist.""" 4841 return _pywrapcp.RoutingModel_GetDimensionOrDie(self, dimension_name)
Returns a dimension from its name. Dies if the dimension does not exist.
def
GetMutableDimension(self, dimension_name):
4843 def GetMutableDimension(self, dimension_name): 4844 r""" 4845 Returns a dimension from its name. Returns nullptr if the dimension does 4846 not exist. 4847 """ 4848 return _pywrapcp.RoutingModel_GetMutableDimension(self, dimension_name)
Returns a dimension from its name. Returns nullptr if the dimension does not exist.
def
SetPrimaryConstrainedDimension(self, dimension_name):
4850 def SetPrimaryConstrainedDimension(self, dimension_name): 4851 r""" 4852 Set the given dimension as "primary constrained". As of August 2013, this 4853 is only used by ArcIsMoreConstrainedThanArc(). 4854 "dimension" must be the name of an existing dimension, or be empty, in 4855 which case there will not be a primary dimension after this call. 4856 """ 4857 return _pywrapcp.RoutingModel_SetPrimaryConstrainedDimension(self, dimension_name)
Set the given dimension as "primary constrained". As of August 2013, this is only used by ArcIsMoreConstrainedThanArc(). "dimension" must be the name of an existing dimension, or be empty, in which case there will not be a primary dimension after this call.
def
GetPrimaryConstrainedDimension(self):
4859 def GetPrimaryConstrainedDimension(self): 4860 r""" Get the primary constrained dimension, or an empty string if it is unset.""" 4861 return _pywrapcp.RoutingModel_GetPrimaryConstrainedDimension(self)
Get the primary constrained dimension, or an empty string if it is unset.
def
AddResourceGroup(self):
4863 def AddResourceGroup(self): 4864 r""" 4865 Adds a resource group to the routing model. Returns its index in 4866 resource_groups_. 4867 """ 4868 return _pywrapcp.RoutingModel_AddResourceGroup(self)
Adds a resource group to the routing model. Returns its index in resource_groups_.
def
GetDimensionResourceGroupIndices(self, dimension):
4876 def GetDimensionResourceGroupIndices(self, dimension): 4877 r""" 4878 Returns the indices of resource groups for this dimension. This method can 4879 only be called after the model has been closed. 4880 """ 4881 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndices(self, dimension)
Returns the indices of resource groups for this dimension. This method can only be called after the model has been closed.
def
GetDimensionResourceGroupIndex(self, dimension):
4883 def GetDimensionResourceGroupIndex(self, dimension): 4884 r""" 4885 Returns the index of the resource group attached to the dimension. 4886 DCHECKS that there's exactly one resource group for this dimension. 4887 """ 4888 return _pywrapcp.RoutingModel_GetDimensionResourceGroupIndex(self, dimension)
Returns the index of the resource group attached to the dimension. DCHECKS that there's exactly one resource group for this dimension.
def
AddDisjunction(self, *args):
4890 def AddDisjunction(self, *args): 4891 r""" 4892 Adds a disjunction constraint on the indices: exactly 'max_cardinality' of 4893 the indices are active. Start and end indices of any vehicle cannot be 4894 part of a disjunction. 4895 4896 If a penalty is given, at most 'max_cardinality' of the indices can be 4897 active, and if less are active, 'penalty' is payed per inactive index. 4898 This is equivalent to adding the constraint: 4899 p + Sum(i)active[i] == max_cardinality 4900 where p is an integer variable, and the following cost to the cost 4901 function: 4902 p * penalty. 4903 'penalty' must be positive to make the disjunction optional; a negative 4904 penalty will force 'max_cardinality' indices of the disjunction to be 4905 performed, and therefore p == 0. 4906 Note: passing a vector with a single index will model an optional index 4907 with a penalty cost if it is not visited. 4908 """ 4909 return _pywrapcp.RoutingModel_AddDisjunction(self, *args)
Adds a disjunction constraint on the indices: exactly 'max_cardinality' of the indices are active. Start and end indices of any vehicle cannot be part of a disjunction.
If a penalty is given, at most 'max_cardinality' of the indices can be active, and if less are active, 'penalty' is payed per inactive index.
This is equivalent to adding the constraint:
p + Sum(i)active[i] == max_cardinality
where p is an integer variable, and the following cost to the cost function: p * penalty. 'penalty' must be positive to make the disjunction optional; a negative penalty will force 'max_cardinality' indices of the disjunction to be performed, and therefore p == 0. Note: passing a vector with a single index will model an optional index with a penalty cost if it is not visited.
def
GetDisjunctionIndices(self, index):
4911 def GetDisjunctionIndices(self, index): 4912 r""" Returns the indices of the disjunctions to which an index belongs.""" 4913 return _pywrapcp.RoutingModel_GetDisjunctionIndices(self, index)
Returns the indices of the disjunctions to which an index belongs.
def
GetDisjunctionPenalty(self, index):
4915 def GetDisjunctionPenalty(self, index): 4916 r""" Returns the penalty of the node disjunction of index 'index'.""" 4917 return _pywrapcp.RoutingModel_GetDisjunctionPenalty(self, index)
Returns the penalty of the node disjunction of index 'index'.
def
GetDisjunctionMaxCardinality(self, index):
4919 def GetDisjunctionMaxCardinality(self, index): 4920 r""" 4921 Returns the maximum number of possible active nodes of the node 4922 disjunction of index 'index'. 4923 """ 4924 return _pywrapcp.RoutingModel_GetDisjunctionMaxCardinality(self, index)
Returns the maximum number of possible active nodes of the node disjunction of index 'index'.
def
GetNumberOfDisjunctions(self):
4926 def GetNumberOfDisjunctions(self): 4927 r""" Returns the number of node disjunctions in the model.""" 4928 return _pywrapcp.RoutingModel_GetNumberOfDisjunctions(self)
Returns the number of node disjunctions in the model.
def
HasMandatoryDisjunctions(self):
4930 def HasMandatoryDisjunctions(self): 4931 r""" 4932 Returns true if the model contains mandatory disjunctions (ones with 4933 kNoPenalty as penalty). 4934 """ 4935 return _pywrapcp.RoutingModel_HasMandatoryDisjunctions(self)
Returns true if the model contains mandatory disjunctions (ones with kNoPenalty as penalty).
def
HasMaxCardinalityConstrainedDisjunctions(self):
4937 def HasMaxCardinalityConstrainedDisjunctions(self): 4938 r""" 4939 Returns true if the model contains at least one disjunction which is 4940 constrained by its max_cardinality. 4941 """ 4942 return _pywrapcp.RoutingModel_HasMaxCardinalityConstrainedDisjunctions(self)
Returns true if the model contains at least one disjunction which is constrained by its max_cardinality.
def
GetPerfectBinaryDisjunctions(self):
4944 def GetPerfectBinaryDisjunctions(self): 4945 r""" 4946 Returns the list of all perfect binary disjunctions, as pairs of variable 4947 indices: a disjunction is "perfect" when its variables do not appear in 4948 any other disjunction. Each pair is sorted (lowest variable index first), 4949 and the output vector is also sorted (lowest pairs first). 4950 """ 4951 return _pywrapcp.RoutingModel_GetPerfectBinaryDisjunctions(self)
Returns the list of all perfect binary disjunctions, as pairs of variable indices: a disjunction is "perfect" when its variables do not appear in any other disjunction. Each pair is sorted (lowest variable index first), and the output vector is also sorted (lowest pairs first).
def
IgnoreDisjunctionsAlreadyForcedToZero(self):
4953 def IgnoreDisjunctionsAlreadyForcedToZero(self): 4954 r""" 4955 SPECIAL: Makes the solver ignore all the disjunctions whose active 4956 variables are all trivially zero (i.e. Max() == 0), by setting their 4957 max_cardinality to 0. 4958 This can be useful when using the BaseBinaryDisjunctionNeighborhood 4959 operators, in the context of arc-based routing. 4960 """ 4961 return _pywrapcp.RoutingModel_IgnoreDisjunctionsAlreadyForcedToZero(self)
SPECIAL: Makes the solver ignore all the disjunctions whose active variables are all trivially zero (i.e. Max() == 0), by setting their max_cardinality to 0. This can be useful when using the BaseBinaryDisjunctionNeighborhood operators, in the context of arc-based routing.
def
AddSoftSameVehicleConstraint(self, indices, cost):
4963 def AddSoftSameVehicleConstraint(self, indices, cost): 4964 r""" 4965 Adds a soft constraint to force a set of variable indices to be on the 4966 same vehicle. If all nodes are not on the same vehicle, each extra vehicle 4967 used adds 'cost' to the cost function. 4968 """ 4969 return _pywrapcp.RoutingModel_AddSoftSameVehicleConstraint(self, indices, cost)
Adds a soft constraint to force a set of variable indices to be on the same vehicle. If all nodes are not on the same vehicle, each extra vehicle used adds 'cost' to the cost function.
def
SetAllowedVehiclesForIndex(self, vehicles, index):
4971 def SetAllowedVehiclesForIndex(self, vehicles, index): 4972 r""" 4973 Sets the vehicles which can visit a given node. If the node is in a 4974 disjunction, this will not prevent it from being unperformed. 4975 Specifying an empty vector of vehicles has no effect (all vehicles 4976 will be allowed to visit the node). 4977 """ 4978 return _pywrapcp.RoutingModel_SetAllowedVehiclesForIndex(self, vehicles, index)
Sets the vehicles which can visit a given node. If the node is in a disjunction, this will not prevent it from being unperformed. Specifying an empty vector of vehicles has no effect (all vehicles will be allowed to visit the node).
def
IsVehicleAllowedForIndex(self, vehicle, index):
4980 def IsVehicleAllowedForIndex(self, vehicle, index): 4981 r""" Returns true if a vehicle is allowed to visit a given node.""" 4982 return _pywrapcp.RoutingModel_IsVehicleAllowedForIndex(self, vehicle, index)
Returns true if a vehicle is allowed to visit a given node.
def
AddPickupAndDelivery(self, pickup, delivery):
4984 def AddPickupAndDelivery(self, pickup, delivery): 4985 r""" 4986 Notifies that index1 and index2 form a pair of nodes which should belong 4987 to the same route. This methods helps the search find better solutions, 4988 especially in the local search phase. 4989 It should be called each time you have an equality constraint linking 4990 the vehicle variables of two node (including for instance pickup and 4991 delivery problems): 4992 Solver* const solver = routing.solver(); 4993 int64_t index1 = manager.NodeToIndex(node1); 4994 int64_t index2 = manager.NodeToIndex(node2); 4995 solver->AddConstraint(solver->MakeEquality( 4996 routing.VehicleVar(index1), 4997 routing.VehicleVar(index2))); 4998 routing.AddPickupAndDelivery(index1, index2); 4999 """ 5000 return _pywrapcp.RoutingModel_AddPickupAndDelivery(self, pickup, delivery)
Notifies that index1 and index2 form a pair of nodes which should belong to the same route. This methods helps the search find better solutions, especially in the local search phase. It should be called each time you have an equality constraint linking the vehicle variables of two node (including for instance pickup and delivery problems): Solver* const solver = routing.solver(); int64_t index1 = manager.NodeToIndex(node1); int64_t index2 = manager.NodeToIndex(node2); solver->AddConstraint(solver->MakeEquality( routing.VehicleVar(index1), routing.VehicleVar(index2))); routing.AddPickupAndDelivery(index1, index2);
def
AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction):
5002 def AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction): 5003 r""" 5004 Same as AddPickupAndDelivery but notifying that the performed node from 5005 the disjunction of index 'pickup_disjunction' is on the same route as the 5006 performed node from the disjunction of index 'delivery_disjunction'. 5007 """ 5008 return _pywrapcp.RoutingModel_AddPickupAndDeliverySets(self, pickup_disjunction, delivery_disjunction)
Same as AddPickupAndDelivery but notifying that the performed node from the disjunction of index 'pickup_disjunction' is on the same route as the performed node from the disjunction of index 'delivery_disjunction'.
def
GetPickupIndexPairs(self, node_index):
5010 def GetPickupIndexPairs(self, node_index): 5011 r""" 5012 Returns pairs for which the node is a pickup; the first element of each 5013 pair is the index in the pickup and delivery pairs list in which the 5014 pickup appears, the second element is its index in the pickups list. 5015 """ 5016 return _pywrapcp.RoutingModel_GetPickupIndexPairs(self, node_index)
Returns pairs for which the node is a pickup; the first element of each pair is the index in the pickup and delivery pairs list in which the pickup appears, the second element is its index in the pickups list.
def
GetDeliveryIndexPairs(self, node_index):
5018 def GetDeliveryIndexPairs(self, node_index): 5019 r""" Same as above for deliveries.""" 5020 return _pywrapcp.RoutingModel_GetDeliveryIndexPairs(self, node_index)
Same as above for deliveries.
def
SetPickupAndDeliveryPolicyOfAllVehicles(self, policy):
5022 def SetPickupAndDeliveryPolicyOfAllVehicles(self, policy): 5023 r""" 5024 Sets the Pickup and delivery policy of all vehicles. It is equivalent to 5025 calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles. 5026 """ 5027 return _pywrapcp.RoutingModel_SetPickupAndDeliveryPolicyOfAllVehicles(self, policy)
Sets the Pickup and delivery policy of all vehicles. It is equivalent to calling SetPickupAndDeliveryPolicyOfVehicle on all vehicles.
def
GetNumOfSingletonNodes(self):
5035 def GetNumOfSingletonNodes(self): 5036 r""" 5037 Returns the number of non-start/end nodes which do not appear in a 5038 pickup/delivery pair. 5039 """ 5040 return _pywrapcp.RoutingModel_GetNumOfSingletonNodes(self)
Returns the number of non-start/end nodes which do not appear in a pickup/delivery pair.
ADDED_TYPE_REMOVED_FROM_VEHICLE =
1
When visited, one instance of type 'T' previously added to the route (TYPE_ADDED_TO_VEHICLE), if any, is removed from the vehicle. If the type was not previously added to the route or all added instances have already been removed, this visit has no effect on the types.
TYPE_ON_VEHICLE_UP_TO_VISIT =
2
With the following policy, the visit enforces that type 'T' is considered on the route from its start until this node is visited.
TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED =
3
The visit doesn't have an impact on the number of types 'T' on the route, as it's (virtually) added and removed directly. This policy can be used for visits which are part of an incompatibility or requirement set without affecting the type count on the route.
def
CloseVisitTypes(self):
5078 def CloseVisitTypes(self): 5079 r""" 5080 This function should be called once all node visit types have been set and 5081 prior to adding any incompatibilities/requirements. 5082 "close" types. 5083 """ 5084 return _pywrapcp.RoutingModel_CloseVisitTypes(self)
This function should be called once all node visit types have been set and prior to adding any incompatibilities/requirements. "close" types.
def
AddHardTypeIncompatibility(self, type1, type2):
5089 def AddHardTypeIncompatibility(self, type1, type2): 5090 r""" 5091 Incompatibilities: 5092 Two nodes with "hard" incompatible types cannot share the same route at 5093 all, while with a "temporal" incompatibility they can't be on the same 5094 route at the same time. 5095 """ 5096 return _pywrapcp.RoutingModel_AddHardTypeIncompatibility(self, type1, type2)
Incompatibilities: Two nodes with "hard" incompatible types cannot share the same route at all, while with a "temporal" incompatibility they can't be on the same route at the same time.
def
GetHardTypeIncompatibilitiesOfType(self, type):
5101 def GetHardTypeIncompatibilitiesOfType(self, type): 5102 r""" Returns visit types incompatible with a given type.""" 5103 return _pywrapcp.RoutingModel_GetHardTypeIncompatibilitiesOfType(self, type)
Returns visit types incompatible with a given type.
def
HasHardTypeIncompatibilities(self):
5108 def HasHardTypeIncompatibilities(self): 5109 r""" 5110 Returns true iff any hard (resp. temporal) type incompatibilities have 5111 been added to the model. 5112 """ 5113 return _pywrapcp.RoutingModel_HasHardTypeIncompatibilities(self)
Returns true iff any hard (resp. temporal) type incompatibilities have been added to the model.
def
AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives):
5118 def AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives): 5119 r""" 5120 Requirements: 5121 NOTE: As of 2019-04, cycles in the requirement graph are not supported, 5122 and lead to the dependent nodes being skipped if possible (otherwise 5123 the model is considered infeasible). 5124 The following functions specify that "dependent_type" requires at least 5125 one of the types in "required_type_alternatives". 5126 5127 For same-vehicle requirements, a node of dependent type type_D requires at 5128 least one node of type type_R among the required alternatives on the same 5129 route. 5130 """ 5131 return _pywrapcp.RoutingModel_AddSameVehicleRequiredTypeAlternatives(self, dependent_type, required_type_alternatives)
Requirements: NOTE: As of 2019-04, cycles in the requirement graph are not supported, and lead to the dependent nodes being skipped if possible (otherwise the model is considered infeasible). The following functions specify that "dependent_type" requires at least one of the types in "required_type_alternatives".
For same-vehicle requirements, a node of dependent type type_D requires at least one node of type type_R among the required alternatives on the same route.
def
AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives):
5133 def AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives): 5134 r""" 5135 If type_D depends on type_R when adding type_D, any node_D of type_D and 5136 VisitTypePolicy TYPE_ADDED_TO_VEHICLE or 5137 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its 5138 vehicle at the time node_D is visited. 5139 """ 5140 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenAddingType(self, dependent_type, required_type_alternatives)
If type_D depends on type_R when adding type_D, any node_D of type_D and VisitTypePolicy TYPE_ADDED_TO_VEHICLE or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED requires at least one type_R on its vehicle at the time node_D is visited.
def
AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives):
5142 def AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives): 5143 r""" 5144 The following requirements apply when visiting dependent nodes that remove 5145 their type from the route, i.e. type_R must be on the vehicle when type_D 5146 of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, 5147 TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is 5148 visited. 5149 """ 5150 return _pywrapcp.RoutingModel_AddRequiredTypeAlternativesWhenRemovingType(self, dependent_type, required_type_alternatives)
The following requirements apply when visiting dependent nodes that remove their type from the route, i.e. type_R must be on the vehicle when type_D of VisitTypePolicy ADDED_TYPE_REMOVED_FROM_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT or TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED is visited.
def
GetSameVehicleRequiredTypeAlternativesOfType(self, type):
5152 def GetSameVehicleRequiredTypeAlternativesOfType(self, type): 5153 r""" 5154 Returns the set of same-vehicle requirement alternatives for the given 5155 type. 5156 """ 5157 return _pywrapcp.RoutingModel_GetSameVehicleRequiredTypeAlternativesOfType(self, type)
Returns the set of same-vehicle requirement alternatives for the given type.
def
GetRequiredTypeAlternativesWhenAddingType(self, type):
5159 def GetRequiredTypeAlternativesWhenAddingType(self, type): 5160 r""" Returns the set of requirement alternatives when adding the given type.""" 5161 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenAddingType(self, type)
Returns the set of requirement alternatives when adding the given type.
def
GetRequiredTypeAlternativesWhenRemovingType(self, type):
5163 def GetRequiredTypeAlternativesWhenRemovingType(self, type): 5164 r""" Returns the set of requirement alternatives when removing the given type.""" 5165 return _pywrapcp.RoutingModel_GetRequiredTypeAlternativesWhenRemovingType(self, type)
Returns the set of requirement alternatives when removing the given type.
def
HasSameVehicleTypeRequirements(self):
5167 def HasSameVehicleTypeRequirements(self): 5168 r""" 5169 Returns true iff any same-route (resp. temporal) type requirements have 5170 been added to the model. 5171 """ 5172 return _pywrapcp.RoutingModel_HasSameVehicleTypeRequirements(self)
Returns true iff any same-route (resp. temporal) type requirements have been added to the model.
def
HasTypeRegulations(self):
5177 def HasTypeRegulations(self): 5178 r""" 5179 Returns true iff the model has any incompatibilities or requirements set 5180 on node types. 5181 """ 5182 return _pywrapcp.RoutingModel_HasTypeRegulations(self)
Returns true iff the model has any incompatibilities or requirements set on node types.
def
UnperformedPenalty(self, var_index):
5184 def UnperformedPenalty(self, var_index): 5185 r""" 5186 Get the "unperformed" penalty of a node. This is only well defined if the 5187 node is only part of a single Disjunction, and that disjunction has a 5188 penalty. For forced active nodes returns max int64_t. In all other cases, 5189 this returns 0. 5190 """ 5191 return _pywrapcp.RoutingModel_UnperformedPenalty(self, var_index)
Get the "unperformed" penalty of a node. This is only well defined if the node is only part of a single Disjunction, and that disjunction has a penalty. For forced active nodes returns max int64_t. In all other cases, this returns 0.
def
UnperformedPenaltyOrValue(self, default_value, var_index):
5193 def UnperformedPenaltyOrValue(self, default_value, var_index): 5194 r""" 5195 Same as above except that it returns default_value instead of 0 when 5196 penalty is not well defined (default value is passed as first argument to 5197 simplify the usage of the method in a callback). 5198 """ 5199 return _pywrapcp.RoutingModel_UnperformedPenaltyOrValue(self, default_value, var_index)
Same as above except that it returns default_value instead of 0 when penalty is not well defined (default value is passed as first argument to simplify the usage of the method in a callback).
def
GetDepot(self):
5201 def GetDepot(self): 5202 r""" 5203 Returns the variable index of the first starting or ending node of all 5204 routes. If all routes start and end at the same node (single depot), this 5205 is the node returned. 5206 """ 5207 return _pywrapcp.RoutingModel_GetDepot(self)
Returns the variable index of the first starting or ending node of all routes. If all routes start and end at the same node (single depot), this is the node returned.
def
SetMaximumNumberOfActiveVehicles(self, max_active_vehicles):
5209 def SetMaximumNumberOfActiveVehicles(self, max_active_vehicles): 5210 r""" 5211 Constrains the maximum number of active vehicles, aka the number of 5212 vehicles which do not have an empty route. For instance, this can be used 5213 to limit the number of routes in the case where there are fewer drivers 5214 than vehicles and that the fleet of vehicle is heterogeneous. 5215 """ 5216 return _pywrapcp.RoutingModel_SetMaximumNumberOfActiveVehicles(self, max_active_vehicles)
Constrains the maximum number of active vehicles, aka the number of vehicles which do not have an empty route. For instance, this can be used to limit the number of routes in the case where there are fewer drivers than vehicles and that the fleet of vehicle is heterogeneous.
def
GetMaximumNumberOfActiveVehicles(self):
5218 def GetMaximumNumberOfActiveVehicles(self): 5219 r""" Returns the maximum number of active vehicles.""" 5220 return _pywrapcp.RoutingModel_GetMaximumNumberOfActiveVehicles(self)
Returns the maximum number of active vehicles.
def
SetArcCostEvaluatorOfAllVehicles(self, evaluator_index):
5222 def SetArcCostEvaluatorOfAllVehicles(self, evaluator_index): 5223 r""" 5224 Sets the cost function of the model such that the cost of a segment of a 5225 route between node 'from' and 'to' is evaluator(from, to), whatever the 5226 route or vehicle performing the route. 5227 """ 5228 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfAllVehicles(self, evaluator_index)
Sets the cost function of the model such that the cost of a segment of a route between node 'from' and 'to' is evaluator(from, to), whatever the route or vehicle performing the route.
def
SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle):
5230 def SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle): 5231 r""" Sets the cost function for a given vehicle route.""" 5232 return _pywrapcp.RoutingModel_SetArcCostEvaluatorOfVehicle(self, evaluator_index, vehicle)
Sets the cost function for a given vehicle route.
def
SetFixedCostOfAllVehicles(self, cost):
5234 def SetFixedCostOfAllVehicles(self, cost): 5235 r""" 5236 Sets the fixed cost of all vehicle routes. It is equivalent to calling 5237 SetFixedCostOfVehicle on all vehicle routes. 5238 """ 5239 return _pywrapcp.RoutingModel_SetFixedCostOfAllVehicles(self, cost)
Sets the fixed cost of all vehicle routes. It is equivalent to calling SetFixedCostOfVehicle on all vehicle routes.
def
SetFixedCostOfVehicle(self, cost, vehicle):
5241 def SetFixedCostOfVehicle(self, cost, vehicle): 5242 r""" Sets the fixed cost of one vehicle route.""" 5243 return _pywrapcp.RoutingModel_SetFixedCostOfVehicle(self, cost, vehicle)
Sets the fixed cost of one vehicle route.
def
GetFixedCostOfVehicle(self, vehicle):
5245 def GetFixedCostOfVehicle(self, vehicle): 5246 r""" 5247 Returns the route fixed cost taken into account if the route of the 5248 vehicle is not empty, aka there's at least one node on the route other 5249 than the first and last nodes. 5250 """ 5251 return _pywrapcp.RoutingModel_GetFixedCostOfVehicle(self, vehicle)
Returns the route fixed cost taken into account if the route of the vehicle is not empty, aka there's at least one node on the route other than the first and last nodes.
def
SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor):
5256 def SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor): 5257 r""" 5258 The following methods set the linear and quadratic cost factors of 5259 vehicles (must be positive values). The default value of these parameters 5260 is zero for all vehicles. 5261 5262 When set, the cost_ of the model will contain terms aiming at reducing the 5263 number of vehicles used in the model, by adding the following to the 5264 objective for every vehicle v: 5265 INDICATOR(v used in the model) * 5266 [linear_cost_factor_of_vehicle_[v] 5267 - quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] 5268 i.e. for every used vehicle, we add the linear factor as fixed cost, and 5269 subtract the square of the route length multiplied by the quadratic 5270 factor. This second term aims at making the routes as dense as possible. 5271 5272 Sets the linear and quadratic cost factor of all vehicles. 5273 """ 5274 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfAllVehicles(self, linear_cost_factor, quadratic_cost_factor)
The following methods set the linear and quadratic cost factors of vehicles (must be positive values). The default value of these parameters is zero for all vehicles.
When set, the cost_ of the model will contain terms aiming at reducing the number of vehicles used in the model, by adding the following to the objective for every vehicle v: INDICATOR(v used in the model) * [linear_cost_factor_of_vehicle_[v]
- quadratic_cost_factor_of_vehicle_[v]*(square of length of route v)] i.e. for every used vehicle, we add the linear factor as fixed cost, and subtract the square of the route length multiplied by the quadratic factor. This second term aims at making the routes as dense as possible.
Sets the linear and quadratic cost factor of all vehicles.
def
SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle):
5276 def SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle): 5277 r""" Sets the linear and quadratic cost factor of the given vehicle.""" 5278 return _pywrapcp.RoutingModel_SetAmortizedCostFactorsOfVehicle(self, linear_cost_factor, quadratic_cost_factor, vehicle)
Sets the linear and quadratic cost factor of the given vehicle.
def
SetFirstSolutionEvaluator(self, evaluator):
5292 def SetFirstSolutionEvaluator(self, evaluator): 5293 r""" 5294 Gets/sets the evaluator used during the search. Only relevant when 5295 RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. 5296 Takes ownership of evaluator. 5297 """ 5298 return _pywrapcp.RoutingModel_SetFirstSolutionEvaluator(self, evaluator)
Gets/sets the evaluator used during the search. Only relevant when RoutingSearchParameters.first_solution_strategy = EVALUATOR_STRATEGY. Takes ownership of evaluator.
def
AddLocalSearchOperator(self, ls_operator):
5300 def AddLocalSearchOperator(self, ls_operator): 5301 r""" 5302 Adds a local search operator to the set of operators used to solve the 5303 vehicle routing problem. 5304 """ 5305 return _pywrapcp.RoutingModel_AddLocalSearchOperator(self, ls_operator)
Adds a local search operator to the set of operators used to solve the vehicle routing problem.
def
AddSearchMonitor(self, monitor):
5307 def AddSearchMonitor(self, monitor): 5308 r""" Adds a search monitor to the search used to solve the routing model.""" 5309 return _pywrapcp.RoutingModel_AddSearchMonitor(self, monitor)
Adds a search monitor to the search used to solve the routing model.
def
AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False):
5311 def AddAtSolutionCallback(self, callback, track_unchecked_neighbors=False): 5312 r""" 5313 Adds a callback called each time a solution is found during the search. 5314 This is a shortcut to creating a monitor to call the callback on 5315 AtSolution() and adding it with AddSearchMonitor. 5316 If track_unchecked_neighbors is true, the callback will also be called on 5317 AcceptUncheckedNeighbor() events, which is useful to grab solutions 5318 obtained when solver_parameters.check_solution_period > 1 (aka fastLS). 5319 """ 5320 return _pywrapcp.RoutingModel_AddAtSolutionCallback(self, callback, track_unchecked_neighbors)
Adds a callback called each time a solution is found during the search. This is a shortcut to creating a monitor to call the callback on AtSolution() and adding it with AddSearchMonitor. If track_unchecked_neighbors is true, the callback will also be called on AcceptUncheckedNeighbor() events, which is useful to grab solutions obtained when solver_parameters.check_solution_period > 1 (aka fastLS).
def
AddVariableMinimizedByFinalizer(self, var):
5322 def AddVariableMinimizedByFinalizer(self, var): 5323 r""" 5324 Adds a variable to minimize in the solution finalizer. The solution 5325 finalizer is called each time a solution is found during the search and 5326 allows to instantiate secondary variables (such as dimension cumul 5327 variables). 5328 """ 5329 return _pywrapcp.RoutingModel_AddVariableMinimizedByFinalizer(self, var)
Adds a variable to minimize in the solution finalizer. The solution finalizer is called each time a solution is found during the search and allows to instantiate secondary variables (such as dimension cumul variables).
def
AddVariableMaximizedByFinalizer(self, var):
5331 def AddVariableMaximizedByFinalizer(self, var): 5332 r""" 5333 Adds a variable to maximize in the solution finalizer (see above for 5334 information on the solution finalizer). 5335 """ 5336 return _pywrapcp.RoutingModel_AddVariableMaximizedByFinalizer(self, var)
Adds a variable to maximize in the solution finalizer (see above for information on the solution finalizer).
def
AddWeightedVariableMinimizedByFinalizer(self, var, cost):
5338 def AddWeightedVariableMinimizedByFinalizer(self, var, cost): 5339 r""" 5340 Adds a variable to minimize in the solution finalizer, with a weighted 5341 priority: the higher the more priority it has. 5342 """ 5343 return _pywrapcp.RoutingModel_AddWeightedVariableMinimizedByFinalizer(self, var, cost)
Adds a variable to minimize in the solution finalizer, with a weighted priority: the higher the more priority it has.
def
AddWeightedVariableMaximizedByFinalizer(self, var, cost):
5345 def AddWeightedVariableMaximizedByFinalizer(self, var, cost): 5346 r""" 5347 Adds a variable to maximize in the solution finalizer, with a weighted 5348 priority: the higher the more priority it has. 5349 """ 5350 return _pywrapcp.RoutingModel_AddWeightedVariableMaximizedByFinalizer(self, var, cost)
Adds a variable to maximize in the solution finalizer, with a weighted priority: the higher the more priority it has.
def
AddVariableTargetToFinalizer(self, var, target):
5352 def AddVariableTargetToFinalizer(self, var, target): 5353 r""" 5354 Add a variable to set the closest possible to the target value in the 5355 solution finalizer. 5356 """ 5357 return _pywrapcp.RoutingModel_AddVariableTargetToFinalizer(self, var, target)
Add a variable to set the closest possible to the target value in the solution finalizer.
def
AddWeightedVariableTargetToFinalizer(self, var, target, cost):
5359 def AddWeightedVariableTargetToFinalizer(self, var, target, cost): 5360 r""" 5361 Same as above with a weighted priority: the higher the cost, the more 5362 priority it has to be set close to the target value. 5363 """ 5364 return _pywrapcp.RoutingModel_AddWeightedVariableTargetToFinalizer(self, var, target, cost)
Same as above with a weighted priority: the higher the cost, the more priority it has to be set close to the target value.
def
CloseModel(self):
5366 def CloseModel(self): 5367 r""" 5368 Closes the current routing model; after this method is called, no 5369 modification to the model can be done, but RoutesToAssignment becomes 5370 available. Note that CloseModel() is automatically called by Solve() and 5371 other methods that produce solution. 5372 This is equivalent to calling 5373 CloseModelWithParameters(DefaultRoutingSearchParameters()). 5374 """ 5375 return _pywrapcp.RoutingModel_CloseModel(self)
Closes the current routing model; after this method is called, no modification to the model can be done, but RoutesToAssignment becomes available. Note that CloseModel() is automatically called by Solve() and other methods that produce solution. This is equivalent to calling CloseModelWithParameters(DefaultRoutingSearchParameters()).
def
CloseModelWithParameters(self, search_parameters):
5377 def CloseModelWithParameters(self, search_parameters): 5378 r""" 5379 Same as above taking search parameters (as of 10/2015 some the parameters 5380 have to be set when closing the model). 5381 """ 5382 return _pywrapcp.RoutingModel_CloseModelWithParameters(self, search_parameters)
Same as above taking search parameters (as of 10/2015 some the parameters have to be set when closing the model).
def
Solve(self, assignment=None):
5384 def Solve(self, assignment=None): 5385 r""" 5386 Solves the current routing model; closes the current model. 5387 This is equivalent to calling 5388 SolveWithParameters(DefaultRoutingSearchParameters()) 5389 or 5390 SolveFromAssignmentWithParameters(assignment, 5391 DefaultRoutingSearchParameters()). 5392 """ 5393 return _pywrapcp.RoutingModel_Solve(self, assignment)
Solves the current routing model; closes the current model. This is equivalent to calling SolveWithParameters(DefaultRoutingSearchParameters()) or SolveFromAssignmentWithParameters(assignment, DefaultRoutingSearchParameters()).
def
SolveWithParameters(self, search_parameters, solutions=None):
5395 def SolveWithParameters(self, search_parameters, solutions=None): 5396 r""" 5397 Solves the current routing model with the given parameters. If 'solutions' 5398 is specified, it will contain the k best solutions found during the search 5399 (from worst to best, including the one returned by this method), where k 5400 corresponds to the 'number_of_solutions_to_collect' in 5401 'search_parameters'. Note that the Assignment returned by the method and 5402 the ones in solutions are owned by the underlying solver and should not be 5403 deleted. 5404 """ 5405 return _pywrapcp.RoutingModel_SolveWithParameters(self, search_parameters, solutions)
Solves the current routing model with the given parameters. If 'solutions' is specified, it will contain the k best solutions found during the search (from worst to best, including the one returned by this method), where k corresponds to the 'number_of_solutions_to_collect' in 'search_parameters'. Note that the Assignment returned by the method and the ones in solutions are owned by the underlying solver and should not be deleted.
def
SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None):
5407 def SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions=None): 5408 r""" 5409 Same as above, except that if assignment is not null, it will be used as 5410 the initial solution. 5411 """ 5412 return _pywrapcp.RoutingModel_SolveFromAssignmentWithParameters(self, assignment, search_parameters, solutions)
Same as above, except that if assignment is not null, it will be used as the initial solution.
def
SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None):
5414 def SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions=None): 5415 r""" 5416 Same as above but will try all assignments in order as first solutions 5417 until one succeeds. 5418 """ 5419 return _pywrapcp.RoutingModel_SolveFromAssignmentsWithParameters(self, assignments, search_parameters, solutions)
Same as above but will try all assignments in order as first solutions until one succeeds.
def
SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment):
5421 def SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment): 5422 r""" 5423 Given a "source_model" and its "source_assignment", resets 5424 "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ 5425 if costs aren't homogeneous across vehicles) of "this" model, with the 5426 values set according to those in "other_assignment". 5427 The objective_element of target_assignment is set to this->cost_. 5428 """ 5429 return _pywrapcp.RoutingModel_SetAssignmentFromOtherModelAssignment(self, target_assignment, source_model, source_assignment)
Given a "source_model" and its "source_assignment", resets "target_assignment" with the IntVar variables (nexts_, and vehicle_vars_ if costs aren't homogeneous across vehicles) of "this" model, with the values set according to those in "other_assignment". The objective_element of target_assignment is set to this->cost_.
def
ComputeLowerBound(self):
5431 def ComputeLowerBound(self): 5432 r""" 5433 Computes a lower bound to the routing problem solving a linear assignment 5434 problem. The routing model must be closed before calling this method. 5435 Note that problems with node disjunction constraints (including optional 5436 nodes) and non-homogenous costs are not supported (the method returns 0 in 5437 these cases). 5438 """ 5439 return _pywrapcp.RoutingModel_ComputeLowerBound(self)
Computes a lower bound to the routing problem solving a linear assignment problem. The routing model must be closed before calling this method. Note that problems with node disjunction constraints (including optional nodes) and non-homogenous costs are not supported (the method returns 0 in these cases).
def
status(self):
5441 def status(self): 5442 r""" Returns the current status of the routing model.""" 5443 return _pywrapcp.RoutingModel_status(self)
Returns the current status of the routing model.
def
enable_deep_serialization(self):
5445 def enable_deep_serialization(self): 5446 r""" Returns the value of the internal enable_deep_serialization_ parameter.""" 5447 return _pywrapcp.RoutingModel_enable_deep_serialization(self)
Returns the value of the internal enable_deep_serialization_ parameter.
def
ApplyLocks(self, locks):
5449 def ApplyLocks(self, locks): 5450 r""" 5451 Applies a lock chain to the next search. 'locks' represents an ordered 5452 vector of nodes representing a partial route which will be fixed during 5453 the next search; it will constrain next variables such that: 5454 next[locks[i]] == locks[i+1]. 5455 5456 Returns the next variable at the end of the locked chain; this variable is 5457 not locked. An assignment containing the locks can be obtained by calling 5458 PreAssignment(). 5459 """ 5460 return _pywrapcp.RoutingModel_ApplyLocks(self, locks)
Applies a lock chain to the next search. 'locks' represents an ordered vector of nodes representing a partial route which will be fixed during the next search; it will constrain next variables such that: next[locks[i]] == locks[i+1].
Returns the next variable at the end of the locked chain; this variable is not locked. An assignment containing the locks can be obtained by calling PreAssignment().
def
ApplyLocksToAllVehicles(self, locks, close_routes):
5462 def ApplyLocksToAllVehicles(self, locks, close_routes): 5463 r""" 5464 Applies lock chains to all vehicles to the next search, such that locks[p] 5465 is the lock chain for route p. Returns false if the locks do not contain 5466 valid routes; expects that the routes do not contain the depots, 5467 i.e. there are empty vectors in place of empty routes. 5468 If close_routes is set to true, adds the end nodes to the route of each 5469 vehicle and deactivates other nodes. 5470 An assignment containing the locks can be obtained by calling 5471 PreAssignment(). 5472 """ 5473 return _pywrapcp.RoutingModel_ApplyLocksToAllVehicles(self, locks, close_routes)
Applies lock chains to all vehicles to the next search, such that locks[p] is the lock chain for route p. Returns false if the locks do not contain valid routes; expects that the routes do not contain the depots, i.e. there are empty vectors in place of empty routes. If close_routes is set to true, adds the end nodes to the route of each vehicle and deactivates other nodes. An assignment containing the locks can be obtained by calling PreAssignment().
def
PreAssignment(self):
5475 def PreAssignment(self): 5476 r""" 5477 Returns an assignment used to fix some of the variables of the problem. 5478 In practice, this assignment locks partial routes of the problem. This 5479 can be used in the context of locking the parts of the routes which have 5480 already been driven in online routing problems. 5481 """ 5482 return _pywrapcp.RoutingModel_PreAssignment(self)
Returns an assignment used to fix some of the variables of the problem. In practice, this assignment locks partial routes of the problem. This can be used in the context of locking the parts of the routes which have already been driven in online routing problems.
def
WriteAssignment(self, file_name):
5487 def WriteAssignment(self, file_name): 5488 r""" 5489 Writes the current solution to a file containing an AssignmentProto. 5490 Returns false if the file cannot be opened or if there is no current 5491 solution. 5492 """ 5493 return _pywrapcp.RoutingModel_WriteAssignment(self, file_name)
Writes the current solution to a file containing an AssignmentProto. Returns false if the file cannot be opened or if there is no current solution.
def
ReadAssignment(self, file_name):
5495 def ReadAssignment(self, file_name): 5496 r""" 5497 Reads an assignment from a file and returns the current solution. 5498 Returns nullptr if the file cannot be opened or if the assignment is not 5499 valid. 5500 """ 5501 return _pywrapcp.RoutingModel_ReadAssignment(self, file_name)
Reads an assignment from a file and returns the current solution. Returns nullptr if the file cannot be opened or if the assignment is not valid.
def
RestoreAssignment(self, solution):
5503 def RestoreAssignment(self, solution): 5504 r""" 5505 Restores an assignment as a solution in the routing model and returns the 5506 new solution. Returns nullptr if the assignment is not valid. 5507 """ 5508 return _pywrapcp.RoutingModel_RestoreAssignment(self, solution)
Restores an assignment as a solution in the routing model and returns the new solution. Returns nullptr if the assignment is not valid.
def
ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices):
5510 def ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices): 5511 r""" 5512 Restores the routes as the current solution. Returns nullptr if the 5513 solution cannot be restored (routes do not contain a valid solution). Note 5514 that calling this method will run the solver to assign values to the 5515 dimension variables; this may take considerable amount of time, especially 5516 when using dimensions with slack. 5517 """ 5518 return _pywrapcp.RoutingModel_ReadAssignmentFromRoutes(self, routes, ignore_inactive_indices)
Restores the routes as the current solution. Returns nullptr if the solution cannot be restored (routes do not contain a valid solution). Note that calling this method will run the solver to assign values to the dimension variables; this may take considerable amount of time, especially when using dimensions with slack.
def
RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment):
5520 def RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment): 5521 r""" 5522 Fills an assignment from a specification of the routes of the 5523 vehicles. The routes are specified as lists of variable indices that 5524 appear on the routes of the vehicles. The indices of the outer vector in 5525 'routes' correspond to vehicles IDs, the inner vector contains the 5526 variable indices on the routes for the given vehicle. The inner vectors 5527 must not contain the start and end indices, as these are determined by the 5528 routing model. Sets the value of NextVars in the assignment, adding the 5529 variables to the assignment if necessary. The method does not touch other 5530 variables in the assignment. The method can only be called after the model 5531 is closed. With ignore_inactive_indices set to false, this method will 5532 fail (return nullptr) in case some of the route contain indices that are 5533 deactivated in the model; when set to true, these indices will be 5534 skipped. Returns true if routes were successfully 5535 loaded. However, such assignment still might not be a valid 5536 solution to the routing problem due to more complex constraints; 5537 it is advisible to call solver()->CheckSolution() afterwards. 5538 """ 5539 return _pywrapcp.RoutingModel_RoutesToAssignment(self, routes, ignore_inactive_indices, close_routes, assignment)
Fills an assignment from a specification of the routes of the vehicles. The routes are specified as lists of variable indices that appear on the routes of the vehicles. The indices of the outer vector in 'routes' correspond to vehicles IDs, the inner vector contains the variable indices on the routes for the given vehicle. The inner vectors must not contain the start and end indices, as these are determined by the routing model. Sets the value of NextVars in the assignment, adding the variables to the assignment if necessary. The method does not touch other variables in the assignment. The method can only be called after the model is closed. With ignore_inactive_indices set to false, this method will fail (return nullptr) in case some of the route contain indices that are deactivated in the model; when set to true, these indices will be skipped. Returns true if routes were successfully loaded. However, such assignment still might not be a valid solution to the routing problem due to more complex constraints; it is advisible to call solver()->CheckSolution() afterwards.
def
AssignmentToRoutes(self, assignment, routes):
5541 def AssignmentToRoutes(self, assignment, routes): 5542 r""" 5543 Converts the solution in the given assignment to routes for all vehicles. 5544 Expects that assignment contains a valid solution (i.e. routes for all 5545 vehicles end with an end index for that vehicle). 5546 """ 5547 return _pywrapcp.RoutingModel_AssignmentToRoutes(self, assignment, routes)
Converts the solution in the given assignment to routes for all vehicles. Expects that assignment contains a valid solution (i.e. routes for all vehicles end with an end index for that vehicle).
def
CompactAssignment(self, assignment):
5549 def CompactAssignment(self, assignment): 5550 r""" 5551 Converts the solution in the given assignment to routes for all vehicles. 5552 If the returned vector is route_indices, route_indices[i][j] is the index 5553 for jth location visited on route i. Note that contrary to 5554 AssignmentToRoutes, the vectors do include start and end locations. 5555 Returns a compacted version of the given assignment, in which all vehicles 5556 with id lower or equal to some N have non-empty routes, and all vehicles 5557 with id greater than N have empty routes. Does not take ownership of the 5558 returned object. 5559 If found, the cost of the compact assignment is the same as in the 5560 original assignment and it preserves the values of 'active' variables. 5561 Returns nullptr if a compact assignment was not found. 5562 This method only works in homogenous mode, and it only swaps equivalent 5563 vehicles (vehicles with the same start and end nodes). When creating the 5564 compact assignment, the empty plan is replaced by the route assigned to 5565 the compatible vehicle with the highest id. Note that with more complex 5566 constraints on vehicle variables, this method might fail even if a compact 5567 solution exists. 5568 This method changes the vehicle and dimension variables as necessary. 5569 While compacting the solution, only basic checks on vehicle variables are 5570 performed; if one of these checks fails no attempts to repair it are made 5571 (instead, the method returns nullptr). 5572 """ 5573 return _pywrapcp.RoutingModel_CompactAssignment(self, assignment)
Converts the solution in the given assignment to routes for all vehicles. If the returned vector is route_indices, route_indices[i][j] is the index for jth location visited on route i. Note that contrary to AssignmentToRoutes, the vectors do include start and end locations. Returns a compacted version of the given assignment, in which all vehicles with id lower or equal to some N have non-empty routes, and all vehicles with id greater than N have empty routes. Does not take ownership of the returned object. If found, the cost of the compact assignment is the same as in the original assignment and it preserves the values of 'active' variables. Returns nullptr if a compact assignment was not found. This method only works in homogenous mode, and it only swaps equivalent vehicles (vehicles with the same start and end nodes). When creating the compact assignment, the empty plan is replaced by the route assigned to the compatible vehicle with the highest id. Note that with more complex constraints on vehicle variables, this method might fail even if a compact solution exists. This method changes the vehicle and dimension variables as necessary. While compacting the solution, only basic checks on vehicle variables are performed; if one of these checks fails no attempts to repair it are made (instead, the method returns nullptr).
def
CompactAndCheckAssignment(self, assignment):
5575 def CompactAndCheckAssignment(self, assignment): 5576 r""" 5577 Same as CompactAssignment() but also checks the validity of the final 5578 compact solution; if it is not valid, no attempts to repair it are made 5579 (instead, the method returns nullptr). 5580 """ 5581 return _pywrapcp.RoutingModel_CompactAndCheckAssignment(self, assignment)
Same as CompactAssignment() but also checks the validity of the final compact solution; if it is not valid, no attempts to repair it are made (instead, the method returns nullptr).
def
AddToAssignment(self, var):
5583 def AddToAssignment(self, var): 5584 r""" Adds an extra variable to the vehicle routing assignment.""" 5585 return _pywrapcp.RoutingModel_AddToAssignment(self, var)
Adds an extra variable to the vehicle routing assignment.
def
PackCumulsOfOptimizerDimensionsFromAssignment( self, original_assignment, duration_limit, time_limit_was_reached=None):
5590 def PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached=None): 5591 r""" 5592 For every dimension in the model with an optimizer in 5593 local/global_dimension_optimizers_, this method tries to pack the cumul 5594 values of the dimension, such that: 5595 - The cumul costs (span costs, soft lower and upper bound costs, etc) are 5596 minimized. 5597 - The cumuls of the ends of the routes are minimized for this given 5598 minimal cumul cost. 5599 - Given these minimal end cumuls, the route start cumuls are maximized. 5600 Returns the assignment resulting from allocating these packed cumuls with 5601 the solver, and nullptr if these cumuls could not be set by the solver. 5602 """ 5603 return _pywrapcp.RoutingModel_PackCumulsOfOptimizerDimensionsFromAssignment(self, original_assignment, duration_limit, time_limit_was_reached)
For every dimension in the model with an optimizer in local/global_dimension_optimizers_, this method tries to pack the cumul values of the dimension, such that:
- The cumul costs (span costs, soft lower and upper bound costs, etc) are minimized.
- The cumuls of the ends of the routes are minimized for this given minimal cumul cost.
- Given these minimal end cumuls, the route start cumuls are maximized. Returns the assignment resulting from allocating these packed cumuls with the solver, and nullptr if these cumuls could not be set by the solver.
def
GetOrCreateNodeNeighborsByCostClass(self, *args):
5605 def GetOrCreateNodeNeighborsByCostClass(self, *args): 5606 r""" 5607 *Overload 1:* 5608 Returns neighbors of all nodes for every cost class. The result is cached 5609 and is computed once. The number of neighbors considered is based on a 5610 ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum 5611 of min-neighbors node considered. 5612 5613 | 5614 5615 *Overload 2:* 5616 Returns parameters.num_neighbors neighbors of all nodes for every cost 5617 class. The result is cached and is computed once. 5618 5619 | 5620 5621 *Overload 3:* 5622 Returns parameters.num_neighbors neighbors of all nodes for every cost 5623 class. The result is cached and is computed once. 5624 """ 5625 return _pywrapcp.RoutingModel_GetOrCreateNodeNeighborsByCostClass(self, *args)
Overload 1: Returns neighbors of all nodes for every cost class. The result is cached and is computed once. The number of neighbors considered is based on a ratio of non-vehicle nodes, specified by neighbors_ratio, with a minimum of min-neighbors node considered.
|
Overload 2: Returns parameters.num_neighbors neighbors of all nodes for every cost class. The result is cached and is computed once.
|
Overload 3: Returns parameters.num_neighbors neighbors of all nodes for every cost class. The result is cached and is computed once.
def
AddLocalSearchFilter(self, filter):
5627 def AddLocalSearchFilter(self, filter): 5628 r""" 5629 Adds a custom local search filter to the list of filters used to speed up 5630 local search by pruning unfeasible variable assignments. 5631 Calling this method after the routing model has been closed (CloseModel() 5632 or Solve() has been called) has no effect. 5633 The routing model does not take ownership of the filter. 5634 """ 5635 return _pywrapcp.RoutingModel_AddLocalSearchFilter(self, filter)
Adds a custom local search filter to the list of filters used to speed up local search by pruning unfeasible variable assignments. Calling this method after the routing model has been closed (CloseModel() or Solve() has been called) has no effect. The routing model does not take ownership of the filter.
def
Start(self, vehicle):
5637 def Start(self, vehicle): 5638 r""" 5639 Model inspection. 5640 Returns the variable index of the starting node of a vehicle route. 5641 """ 5642 return _pywrapcp.RoutingModel_Start(self, vehicle)
Model inspection. Returns the variable index of the starting node of a vehicle route.
def
End(self, vehicle):
5644 def End(self, vehicle): 5645 r""" Returns the variable index of the ending node of a vehicle route.""" 5646 return _pywrapcp.RoutingModel_End(self, vehicle)
Returns the variable index of the ending node of a vehicle route.
def
IsStart(self, index):
5648 def IsStart(self, index): 5649 r""" Returns true if 'index' represents the first node of a route.""" 5650 return _pywrapcp.RoutingModel_IsStart(self, index)
Returns true if 'index' represents the first node of a route.
def
IsEnd(self, index):
5652 def IsEnd(self, index): 5653 r""" Returns true if 'index' represents the last node of a route.""" 5654 return _pywrapcp.RoutingModel_IsEnd(self, index)
Returns true if 'index' represents the last node of a route.
def
VehicleIndex(self, index):
5656 def VehicleIndex(self, index): 5657 r""" 5658 Returns the vehicle of the given start/end index, and -1 if the given 5659 index is not a vehicle start/end. 5660 """ 5661 return _pywrapcp.RoutingModel_VehicleIndex(self, index)
Returns the vehicle of the given start/end index, and -1 if the given index is not a vehicle start/end.
def
Next(self, assignment, index):
5663 def Next(self, assignment, index): 5664 r""" 5665 Assignment inspection 5666 Returns the variable index of the node directly after the node 5667 corresponding to 'index' in 'assignment'. 5668 """ 5669 return _pywrapcp.RoutingModel_Next(self, assignment, index)
Assignment inspection Returns the variable index of the node directly after the node corresponding to 'index' in 'assignment'.
def
IsVehicleUsed(self, assignment, vehicle):
5671 def IsVehicleUsed(self, assignment, vehicle): 5672 r""" Returns true if the route of 'vehicle' is non empty in 'assignment'.""" 5673 return _pywrapcp.RoutingModel_IsVehicleUsed(self, assignment, vehicle)
Returns true if the route of 'vehicle' is non empty in 'assignment'.
def
NextVar(self, index):
5675 def NextVar(self, index): 5676 r""" 5677 Returns the next variable of the node corresponding to index. Note that 5678 NextVar(index) == index is equivalent to ActiveVar(index) == 0. 5679 """ 5680 return _pywrapcp.RoutingModel_NextVar(self, index)
Returns the next variable of the node corresponding to index. Note that NextVar(index) == index is equivalent to ActiveVar(index) == 0.
def
ActiveVar(self, index):
5682 def ActiveVar(self, index): 5683 r""" Returns the active variable of the node corresponding to index.""" 5684 return _pywrapcp.RoutingModel_ActiveVar(self, index)
Returns the active variable of the node corresponding to index.
def
ActiveVehicleVar(self, vehicle):
5686 def ActiveVehicleVar(self, vehicle): 5687 r""" 5688 Returns the active variable of the vehicle. It will be equal to 1 iff the 5689 route of the vehicle is not empty, 0 otherwise. 5690 """ 5691 return _pywrapcp.RoutingModel_ActiveVehicleVar(self, vehicle)
Returns the active variable of the vehicle. It will be equal to 1 iff the route of the vehicle is not empty, 0 otherwise.
def
VehicleRouteConsideredVar(self, vehicle):
5693 def VehicleRouteConsideredVar(self, vehicle): 5694 r""" 5695 Returns the variable specifying whether or not the given vehicle route is 5696 considered for costs and constraints. It will be equal to 1 iff the route 5697 of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true. 5698 """ 5699 return _pywrapcp.RoutingModel_VehicleRouteConsideredVar(self, vehicle)
Returns the variable specifying whether or not the given vehicle route is considered for costs and constraints. It will be equal to 1 iff the route of the vehicle is not empty OR vehicle_used_when_empty_[vehicle] is true.
def
VehicleVar(self, index):
5701 def VehicleVar(self, index): 5702 r""" 5703 Returns the vehicle variable of the node corresponding to index. Note that 5704 VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0. 5705 """ 5706 return _pywrapcp.RoutingModel_VehicleVar(self, index)
Returns the vehicle variable of the node corresponding to index. Note that VehicleVar(index) == -1 is equivalent to ActiveVar(index) == 0.
def
ResourceVar(self, vehicle, resource_group):
5708 def ResourceVar(self, vehicle, resource_group): 5709 r""" 5710 Returns the resource variable for the given vehicle index in the given 5711 resource group. If a vehicle doesn't require a resource from the 5712 corresponding resource group, then ResourceVar(v, r_g) == -1. 5713 """ 5714 return _pywrapcp.RoutingModel_ResourceVar(self, vehicle, resource_group)
Returns the resource variable for the given vehicle index in the given resource group. If a vehicle doesn't require a resource from the corresponding resource group, then ResourceVar(v, r_g) == -1.
def
CostVar(self):
5716 def CostVar(self): 5717 r""" Returns the global cost variable which is being minimized.""" 5718 return _pywrapcp.RoutingModel_CostVar(self)
Returns the global cost variable which is being minimized.
def
GetArcCostForVehicle(self, from_index, to_index, vehicle):
5720 def GetArcCostForVehicle(self, from_index, to_index, vehicle): 5721 r""" 5722 Returns the cost of the transit arc between two nodes for a given vehicle. 5723 Input are variable indices of node. This returns 0 if vehicle < 0. 5724 """ 5725 return _pywrapcp.RoutingModel_GetArcCostForVehicle(self, from_index, to_index, vehicle)
Returns the cost of the transit arc between two nodes for a given vehicle. Input are variable indices of node. This returns 0 if vehicle < 0.
def
CostsAreHomogeneousAcrossVehicles(self):
5727 def CostsAreHomogeneousAcrossVehicles(self): 5728 r""" Whether costs are homogeneous across all vehicles.""" 5729 return _pywrapcp.RoutingModel_CostsAreHomogeneousAcrossVehicles(self)
Whether costs are homogeneous across all vehicles.
def
GetHomogeneousCost(self, from_index, to_index):
5731 def GetHomogeneousCost(self, from_index, to_index): 5732 r""" 5733 Returns the cost of the segment between two nodes supposing all vehicle 5734 costs are the same (returns the cost for the first vehicle otherwise). 5735 """ 5736 return _pywrapcp.RoutingModel_GetHomogeneousCost(self, from_index, to_index)
Returns the cost of the segment between two nodes supposing all vehicle costs are the same (returns the cost for the first vehicle otherwise).
def
GetArcCostForFirstSolution(self, from_index, to_index):
5738 def GetArcCostForFirstSolution(self, from_index, to_index): 5739 r""" 5740 Returns the cost of the arc in the context of the first solution strategy. 5741 This is typically a simplification of the actual cost; see the .cc. 5742 """ 5743 return _pywrapcp.RoutingModel_GetArcCostForFirstSolution(self, from_index, to_index)
Returns the cost of the arc in the context of the first solution strategy. This is typically a simplification of the actual cost; see the .cc.
def
GetArcCostForClass(self, from_index, to_index, cost_class_index):
5745 def GetArcCostForClass(self, from_index, to_index, cost_class_index): 5746 r""" 5747 Returns the cost of the segment between two nodes for a given cost 5748 class. Input are variable indices of nodes and the cost class. 5749 Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the 5750 returned cost won't necessarily be zero: only some of the components 5751 of the cost that depend on the cost class will be omited. See the code 5752 for details. 5753 """ 5754 return _pywrapcp.RoutingModel_GetArcCostForClass(self, from_index, to_index, cost_class_index)
Returns the cost of the segment between two nodes for a given cost class. Input are variable indices of nodes and the cost class. Unlike GetArcCostForVehicle(), if cost_class is kNoCost, then the returned cost won't necessarily be zero: only some of the components of the cost that depend on the cost class will be omited. See the code for details.
def
GetCostClassIndexOfVehicle(self, vehicle):
5756 def GetCostClassIndexOfVehicle(self, vehicle): 5757 r""" Get the cost class index of the given vehicle.""" 5758 return _pywrapcp.RoutingModel_GetCostClassIndexOfVehicle(self, vehicle)
Get the cost class index of the given vehicle.
def
HasVehicleWithCostClassIndex(self, cost_class_index):
5760 def HasVehicleWithCostClassIndex(self, cost_class_index): 5761 r""" 5762 Returns true iff the model contains a vehicle with the given 5763 cost_class_index. 5764 """ 5765 return _pywrapcp.RoutingModel_HasVehicleWithCostClassIndex(self, cost_class_index)
Returns true iff the model contains a vehicle with the given cost_class_index.
def
GetCostClassesCount(self):
5767 def GetCostClassesCount(self): 5768 r""" Returns the number of different cost classes in the model.""" 5769 return _pywrapcp.RoutingModel_GetCostClassesCount(self)
Returns the number of different cost classes in the model.
def
GetNonZeroCostClassesCount(self):
5771 def GetNonZeroCostClassesCount(self): 5772 r""" Ditto, minus the 'always zero', built-in cost class.""" 5773 return _pywrapcp.RoutingModel_GetNonZeroCostClassesCount(self)
Ditto, minus the 'always zero', built-in cost class.
def
GetVehicleOfClass(self, vehicle_class):
5778 def GetVehicleOfClass(self, vehicle_class): 5779 r""" 5780 Returns a vehicle of the given vehicle class, and -1 if there are no 5781 vehicles for this class. 5782 """ 5783 return _pywrapcp.RoutingModel_GetVehicleOfClass(self, vehicle_class)
Returns a vehicle of the given vehicle class, and -1 if there are no vehicles for this class.
def
GetVehicleClassesCount(self):
5785 def GetVehicleClassesCount(self): 5786 r""" Returns the number of different vehicle classes in the model.""" 5787 return _pywrapcp.RoutingModel_GetVehicleClassesCount(self)
Returns the number of different vehicle classes in the model.
def
GetSameVehicleIndicesOfIndex(self, node):
5789 def GetSameVehicleIndicesOfIndex(self, node): 5790 r""" Returns variable indices of nodes constrained to be on the same route.""" 5791 return _pywrapcp.RoutingModel_GetSameVehicleIndicesOfIndex(self, node)
Returns variable indices of nodes constrained to be on the same route.
def
ArcIsMoreConstrainedThanArc(self, _from, to1, to2):
5796 def ArcIsMoreConstrainedThanArc(self, _from, to1, to2): 5797 r""" 5798 Returns whether the arc from->to1 is more constrained than from->to2, 5799 taking into account, in order: 5800 - whether the destination node isn't an end node 5801 - whether the destination node is mandatory 5802 - whether the destination node is bound to the same vehicle as the source 5803 - the "primary constrained" dimension (see SetPrimaryConstrainedDimension) 5804 It then breaks ties using, in order: 5805 - the arc cost (taking unperformed penalties into account) 5806 - the size of the vehicle vars of "to1" and "to2" (lowest size wins) 5807 - the value: the lowest value of the indices to1 and to2 wins. 5808 See the .cc for details. 5809 The more constrained arc is typically preferable when building a 5810 first solution. This method is intended to be used as a callback for the 5811 BestValueByComparisonSelector value selector. 5812 Args: 5813 from: the variable index of the source node 5814 to1: the variable index of the first candidate destination node. 5815 to2: the variable index of the second candidate destination node. 5816 """ 5817 return _pywrapcp.RoutingModel_ArcIsMoreConstrainedThanArc(self, _from, to1, to2)
Returns whether the arc from->to1 is more constrained than from->to2, taking into account, in order:
- whether the destination node isn't an end node
- whether the destination node is mandatory
- whether the destination node is bound to the same vehicle as the source
- the "primary constrained" dimension (see SetPrimaryConstrainedDimension) It then breaks ties using, in order:
- the arc cost (taking unperformed penalties into account)
- the size of the vehicle vars of "to1" and "to2" (lowest size wins)
- the value: the lowest value of the indices to1 and to2 wins. See the .cc for details. The more constrained arc is typically preferable when building a first solution. This method is intended to be used as a callback for the BestValueByComparisonSelector value selector.
Arguments:
- from: the variable index of the source node
- to1: the variable index of the first candidate destination node.
- to2: the variable index of the second candidate destination node.
def
DebugOutputAssignment(self, solution_assignment, dimension_to_print):
5819 def DebugOutputAssignment(self, solution_assignment, dimension_to_print): 5820 r""" 5821 Print some debugging information about an assignment, including the 5822 feasible intervals of the CumulVar for dimension "dimension_to_print" 5823 at each step of the routes. 5824 If "dimension_to_print" is omitted, all dimensions will be printed. 5825 """ 5826 return _pywrapcp.RoutingModel_DebugOutputAssignment(self, solution_assignment, dimension_to_print)
Print some debugging information about an assignment, including the feasible intervals of the CumulVar for dimension "dimension_to_print" at each step of the routes. If "dimension_to_print" is omitted, all dimensions will be printed.
def
solver(self):
5828 def solver(self): 5829 r""" 5830 Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair 5831 containing the minimum and maximum of the CumulVar of the jth node on 5832 route i. 5833 - cumul_bounds[i][j].first is the minimum. 5834 - cumul_bounds[i][j].second is the maximum. 5835 Returns the underlying constraint solver. Can be used to add extra 5836 constraints and/or modify search algorithms. 5837 """ 5838 return _pywrapcp.RoutingModel_solver(self)
Returns a vector cumul_bounds, for which cumul_bounds[i][j] is a pair containing the minimum and maximum of the CumulVar of the jth node on route i.
- cumul_bounds[i][j].first is the minimum.
- cumul_bounds[i][j].second is the maximum. Returns the underlying constraint solver. Can be used to add extra constraints and/or modify search algorithms.
def
CheckLimit(self, *args):
5840 def CheckLimit(self, *args): 5841 r""" 5842 Returns true if the search limit has been crossed with the given time 5843 offset. 5844 """ 5845 return _pywrapcp.RoutingModel_CheckLimit(self, *args)
Returns true if the search limit has been crossed with the given time offset.
def
RemainingTime(self):
5847 def RemainingTime(self): 5848 r""" Returns the time left in the search limit.""" 5849 return _pywrapcp.RoutingModel_RemainingTime(self)
Returns the time left in the search limit.
def
TimeBuffer(self):
5851 def TimeBuffer(self): 5852 r""" Returns the time buffer to safely return a solution.""" 5853 return _pywrapcp.RoutingModel_TimeBuffer(self)
Returns the time buffer to safely return a solution.
def
nodes(self):
5855 def nodes(self): 5856 r""" 5857 Sizes and indices 5858 Returns the number of nodes in the model. 5859 """ 5860 return _pywrapcp.RoutingModel_nodes(self)
Sizes and indices Returns the number of nodes in the model.
def
vehicles(self):
5862 def vehicles(self): 5863 r""" Returns the number of vehicle routes in the model.""" 5864 return _pywrapcp.RoutingModel_vehicles(self)
Returns the number of vehicle routes in the model.
def
Size(self):
5866 def Size(self): 5867 r""" Returns the number of next variables in the model.""" 5868 return _pywrapcp.RoutingModel_Size(self)
Returns the number of next variables in the model.
def
GetNumberOfDecisionsInFirstSolution(self, search_parameters):
5870 def GetNumberOfDecisionsInFirstSolution(self, search_parameters): 5871 r""" 5872 Returns statistics on first solution search, number of decisions sent to 5873 filters, number of decisions rejected by filters. 5874 """ 5875 return _pywrapcp.RoutingModel_GetNumberOfDecisionsInFirstSolution(self, search_parameters)
Returns statistics on first solution search, number of decisions sent to filters, number of decisions rejected by filters.
def
GetAutomaticFirstSolutionStrategy(self):
5880 def GetAutomaticFirstSolutionStrategy(self): 5881 r""" Returns the automatic first solution strategy selected.""" 5882 return _pywrapcp.RoutingModel_GetAutomaticFirstSolutionStrategy(self)
Returns the automatic first solution strategy selected.
def
IsMatchingModel(self):
5884 def IsMatchingModel(self): 5885 r""" Returns true if a vehicle/node matching problem is detected.""" 5886 return _pywrapcp.RoutingModel_IsMatchingModel(self)
Returns true if a vehicle/node matching problem is detected.
def
AreRoutesInterdependent(self, parameters):
5888 def AreRoutesInterdependent(self, parameters): 5889 r""" 5890 Returns true if routes are interdependent. This means that any 5891 modification to a route might impact another. 5892 """ 5893 return _pywrapcp.RoutingModel_AreRoutesInterdependent(self, parameters)
Returns true if routes are interdependent. This means that any modification to a route might impact another.
def
MakeGuidedSlackFinalizer(self, dimension, initializer):
5895 def MakeGuidedSlackFinalizer(self, dimension, initializer): 5896 r""" 5897 The next few members are in the public section only for testing purposes. 5898 5899 MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a 5900 dimension using a callback to choose which values to start with. 5901 The finalizer works only when all next variables in the model have 5902 been fixed. It has the following two characteristics: 5903 1. It follows the routes defined by the nexts variables when choosing a 5904 variable to make a decision on. 5905 2. When it comes to choose a value for the slack of node i, the decision 5906 builder first calls the callback with argument i, and supposingly the 5907 returned value is x it creates decisions slack[i] = x, slack[i] = x + 5908 1, slack[i] = x - 1, slack[i] = x + 2, etc. 5909 """ 5910 return _pywrapcp.RoutingModel_MakeGuidedSlackFinalizer(self, dimension, initializer)
The next few members are in the public section only for testing purposes.
MakeGuidedSlackFinalizer creates a DecisionBuilder for the slacks of a dimension using a callback to choose which values to start with. The finalizer works only when all next variables in the model have been fixed. It has the following two characteristics:
- It follows the routes defined by the nexts variables when choosing a variable to make a decision on.
- When it comes to choose a value for the slack of node i, the decision builder first calls the callback with argument i, and supposingly the returned value is x it creates decisions slack[i] = x, slack[i] = x + 1, slack[i] = x - 1, slack[i] = x + 2, etc.
def
MakeSelfDependentDimensionFinalizer(self, dimension):
5912 def MakeSelfDependentDimensionFinalizer(self, dimension): 5913 r""" 5914 MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a 5915 self-dependent dimension. It makes an extensive use of the caches of the 5916 state dependent transits. 5917 In detail, MakeSelfDependentDimensionFinalizer returns a composition of a 5918 local search decision builder with a greedy descent operator for the cumul 5919 of the start of each route and a guided slack finalizer. Provided there 5920 are no time windows and the maximum slacks are large enough, once the 5921 cumul of the start of route is fixed, the guided finalizer can find 5922 optimal values of the slacks for the rest of the route in time 5923 proportional to the length of the route. Therefore the composed finalizer 5924 generally works in time O(log(t)*n*m), where t is the latest possible 5925 departute time, n is the number of nodes in the network and m is the 5926 number of vehicles. 5927 """ 5928 return _pywrapcp.RoutingModel_MakeSelfDependentDimensionFinalizer(self, dimension)
MakeSelfDependentDimensionFinalizer is a finalizer for the slacks of a self-dependent dimension. It makes an extensive use of the caches of the state dependent transits. In detail, MakeSelfDependentDimensionFinalizer returns a composition of a local search decision builder with a greedy descent operator for the cumul of the start of each route and a guided slack finalizer. Provided there are no time windows and the maximum slacks are large enough, once the cumul of the start of route is fixed, the guided finalizer can find optimal values of the slacks for the rest of the route in time proportional to the length of the route. Therefore the composed finalizer generally works in time O(log(t)nm), where t is the latest possible departute time, n is the number of nodes in the network and m is the number of vehicles.
cvar =
<Swig global variables>
5940class RoutingModelVisitor(BaseObject): 5941 r""" Routing model visitor.""" 5942 5943 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5944 __repr__ = _swig_repr 5945 5946 def __init__(self): 5947 _pywrapcp.RoutingModelVisitor_swiginit(self, _pywrapcp.new_RoutingModelVisitor()) 5948 __swig_destroy__ = _pywrapcp.delete_RoutingModelVisitor
Routing model visitor.
Inherited Members
5956class GlobalVehicleBreaksConstraint(Constraint): 5957 r""" 5958 GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on 5959 all vehicles in the dimension passed to its constructor. 5960 It is intended to be used for dimensions representing time. 5961 A break constraint ensures break intervals fit on the route of a vehicle. 5962 For a given vehicle, it forces break intervals to be disjoint from visit 5963 intervals, where visit intervals start at CumulVar(node) and last for 5964 node_visit_transit[node]. Moreover, it ensures that there is enough time 5965 between two consecutive nodes of a route to do transit and vehicle breaks, 5966 i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB, 5967 then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break). 5968 """ 5969 5970 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5971 __repr__ = _swig_repr 5972 5973 def __init__(self, dimension): 5974 _pywrapcp.GlobalVehicleBreaksConstraint_swiginit(self, _pywrapcp.new_GlobalVehicleBreaksConstraint(dimension)) 5975 5976 def DebugString(self): 5977 return _pywrapcp.GlobalVehicleBreaksConstraint_DebugString(self) 5978 5979 def Post(self): 5980 return _pywrapcp.GlobalVehicleBreaksConstraint_Post(self) 5981 5982 def InitialPropagateWrapper(self): 5983 return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self) 5984 __swig_destroy__ = _pywrapcp.delete_GlobalVehicleBreaksConstraint
GlobalVehicleBreaksConstraint ensures breaks constraints are enforced on all vehicles in the dimension passed to its constructor. It is intended to be used for dimensions representing time. A break constraint ensures break intervals fit on the route of a vehicle. For a given vehicle, it forces break intervals to be disjoint from visit intervals, where visit intervals start at CumulVar(node) and last for node_visit_transit[node]. Moreover, it ensures that there is enough time between two consecutive nodes of a route to do transit and vehicle breaks, i.e. if Next(nodeA) = nodeB, CumulVar(nodeA) = tA and CumulVar(nodeB) = tB, then SlackVar(nodeA) >= sum_{breaks [tA, tB)} duration(break).
def
Post(self):
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
5982 def InitialPropagateWrapper(self): 5983 return _pywrapcp.GlobalVehicleBreaksConstraint_InitialPropagateWrapper(self)
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
class
TypeRegulationsChecker:
5988class TypeRegulationsChecker(object): 5989 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 5990 5991 def __init__(self, *args, **kwargs): 5992 raise AttributeError("No constructor defined - class is abstract") 5993 __repr__ = _swig_repr 5994 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsChecker 5995 5996 def CheckVehicle(self, vehicle, next_accessor): 5997 return _pywrapcp.TypeRegulationsChecker_CheckVehicle(self, vehicle, next_accessor)
6001class TypeIncompatibilityChecker(TypeRegulationsChecker): 6002 r""" Checker for type incompatibilities.""" 6003 6004 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6005 __repr__ = _swig_repr 6006 6007 def __init__(self, model, check_hard_incompatibilities): 6008 _pywrapcp.TypeIncompatibilityChecker_swiginit(self, _pywrapcp.new_TypeIncompatibilityChecker(model, check_hard_incompatibilities)) 6009 __swig_destroy__ = _pywrapcp.delete_TypeIncompatibilityChecker
Checker for type incompatibilities.
Inherited Members
6013class TypeRequirementChecker(TypeRegulationsChecker): 6014 r""" Checker for type requirements.""" 6015 6016 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6017 __repr__ = _swig_repr 6018 6019 def __init__(self, model): 6020 _pywrapcp.TypeRequirementChecker_swiginit(self, _pywrapcp.new_TypeRequirementChecker(model)) 6021 __swig_destroy__ = _pywrapcp.delete_TypeRequirementChecker
Checker for type requirements.
Inherited Members
6025class TypeRegulationsConstraint(Constraint): 6026 r""" 6027 The following constraint ensures that incompatibilities and requirements 6028 between types are respected. 6029 6030 It verifies both "hard" and "temporal" incompatibilities. 6031 Two nodes with hard incompatible types cannot be served by the same vehicle 6032 at all, while with a temporal incompatibility they can't be on the same 6033 route at the same time. 6034 The VisitTypePolicy of a node determines how visiting it impacts the type 6035 count on the route. 6036 6037 For example, for 6038 - three temporally incompatible types T1 T2 and T3 6039 - 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with 6040 - a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE 6041 - r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE 6042 - 3 nodes A, UV and AR of type T3, respectively with type policies 6043 TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and 6044 TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED 6045 the configurations 6046 UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and 6047 a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations 6048 a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or 6049 a1 --> r1 --> UV --> ... are not feasible. 6050 6051 It also verifies same-vehicle and temporal type requirements. 6052 A node of type T_d with a same-vehicle requirement for type T_r needs to be 6053 served by the same vehicle as a node of type T_r. 6054 Temporal requirements, on the other hand, can take effect either when the 6055 dependent type is being added to the route or when it's removed from it, 6056 which is determined by the dependent node's VisitTypePolicy. 6057 In the above example: 6058 - If T3 is required on the same vehicle as T1, A, AR or UV must be on the 6059 same vehicle as a1. 6060 - If T2 is required when adding T1, a2 must be visited *before* a1, and if 6061 r2 is also visited on the route, it must be *after* a1, i.e. T2 must be on 6062 the vehicle when a1 is visited: 6063 ... --> a2 --> ... --> a1 --> ... --> r2 --> ... 6064 - If T3 is required when removing T1, T3 needs to be on the vehicle when 6065 r1 is visited: 6066 ... --> A --> ... --> r1 --> ... OR ... --> r1 --> ... --> UV --> ... 6067 """ 6068 6069 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6070 __repr__ = _swig_repr 6071 6072 def __init__(self, model): 6073 _pywrapcp.TypeRegulationsConstraint_swiginit(self, _pywrapcp.new_TypeRegulationsConstraint(model)) 6074 6075 def Post(self): 6076 return _pywrapcp.TypeRegulationsConstraint_Post(self) 6077 6078 def InitialPropagateWrapper(self): 6079 return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self) 6080 __swig_destroy__ = _pywrapcp.delete_TypeRegulationsConstraint
The following constraint ensures that incompatibilities and requirements between types are respected.
It verifies both "hard" and "temporal" incompatibilities. Two nodes with hard incompatible types cannot be served by the same vehicle at all, while with a temporal incompatibility they can't be on the same route at the same time. The VisitTypePolicy of a node determines how visiting it impacts the type count on the route.
For example, for
- three temporally incompatible types T1 T2 and T3
- 2 pairs of nodes a1/r1 and a2/r2 of type T1 and T2 respectively, with
- a1 and a2 of VisitTypePolicy TYPE_ADDED_TO_VEHICLE
- r1 and r2 of policy ADDED_TYPE_REMOVED_FROM_VEHICLE
- 3 nodes A, UV and AR of type T3, respectively with type policies TYPE_ADDED_TO_VEHICLE, TYPE_ON_VEHICLE_UP_TO_VISIT and TYPE_SIMULTANEOUSLY_ADDED_AND_REMOVED the configurations UV --> a1 --> r1 --> a2 --> r2, a1 --> r1 --> a2 --> r2 --> A and a1 --> r1 --> AR --> a2 --> r2 are acceptable, whereas the configurations a1 --> a2 --> r1 --> ..., or A --> a1 --> r1 --> ..., or a1 --> r1 --> UV --> ... are not feasible.
It also verifies same-vehicle and temporal type requirements. A node of type T_d with a same-vehicle requirement for type T_r needs to be served by the same vehicle as a node of type T_r. Temporal requirements, on the other hand, can take effect either when the dependent type is being added to the route or when it's removed from it, which is determined by the dependent node's VisitTypePolicy. In the above example:
- If T3 is required on the same vehicle as T1, A, AR or UV must be on the same vehicle as a1.
- If T2 is required when adding T1, a2 must be visited before a1, and if r2 is also visited on the route, it must be after a1, i.e. T2 must be on the vehicle when a1 is visited: ... --> a2 --> ... --> a1 --> ... --> r2 --> ...
- If T3 is required when removing T1, T3 needs to be on the vehicle when r1 is visited: ... --> A --> ... --> r1 --> ... OR ... --> r1 --> ... --> UV --> ...
def
Post(self):
This method is called when the constraint is processed by the solver. Its main usage is to attach demons to variables.
def
InitialPropagateWrapper(self):
6078 def InitialPropagateWrapper(self): 6079 return _pywrapcp.TypeRegulationsConstraint_InitialPropagateWrapper(self)
This method performs the initial propagation of the constraint. It is called just after the post.
Inherited Members
class
BoundCost:
6084class BoundCost(object): 6085 r""" 6086 A structure meant to store soft bounds and associated violation constants. 6087 It is 'Simple' because it has one BoundCost per element, 6088 in contrast to 'Multiple'. Design notes: 6089 - it is meant to store model information to be shared through pointers, 6090 so it disallows copy and assign to avoid accidental duplication. 6091 - it keeps soft bounds as an array of structs to help cache, 6092 because code that uses such bounds typically use both bound and cost. 6093 - soft bounds are named pairs, prevents some mistakes. 6094 - using operator[] to access elements is not interesting, 6095 because the structure will be accessed through pointers, moreover having 6096 to type bound_cost reminds the user of the order if they do a copy 6097 assignment of the element. 6098 """ 6099 6100 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6101 __repr__ = _swig_repr 6102 bound = property(_pywrapcp.BoundCost_bound_get, _pywrapcp.BoundCost_bound_set) 6103 cost = property(_pywrapcp.BoundCost_cost_get, _pywrapcp.BoundCost_cost_set) 6104 6105 def __init__(self, *args): 6106 _pywrapcp.BoundCost_swiginit(self, _pywrapcp.new_BoundCost(*args)) 6107 __swig_destroy__ = _pywrapcp.delete_BoundCost
A structure meant to store soft bounds and associated violation constants. It is 'Simple' because it has one BoundCost per element, in contrast to 'Multiple'. Design notes:
- it is meant to store model information to be shared through pointers, so it disallows copy and assign to avoid accidental duplication.
- it keeps soft bounds as an array of structs to help cache, because code that uses such bounds typically use both bound and cost.
- soft bounds are named pairs, prevents some mistakes.
- using operator[] to access elements is not interesting, because the structure will be accessed through pointers, moreover having to type bound_cost reminds the user of the order if they do a copy assignment of the element.
class
SimpleBoundCosts:
6111class SimpleBoundCosts(object): 6112 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6113 __repr__ = _swig_repr 6114 6115 def __init__(self, num_bounds, default_bound_cost): 6116 _pywrapcp.SimpleBoundCosts_swiginit(self, _pywrapcp.new_SimpleBoundCosts(num_bounds, default_bound_cost)) 6117 6118 def bound_cost(self, element): 6119 return _pywrapcp.SimpleBoundCosts_bound_cost(self, element) 6120 6121 def size(self): 6122 return _pywrapcp.SimpleBoundCosts_size(self) 6123 __swig_destroy__ = _pywrapcp.delete_SimpleBoundCosts
class
RoutingDimension:
6127class RoutingDimension(object): 6128 r""" 6129 Dimensions represent quantities accumulated at nodes along the routes. They 6130 represent quantities such as weights or volumes carried along the route, or 6131 distance or times. 6132 6133 Quantities at a node are represented by "cumul" variables and the increase 6134 or decrease of quantities between nodes are represented by "transit" 6135 variables. These variables are linked as follows: 6136 6137 if j == next(i), 6138 cumuls(j) = cumuls(i) + transits(i) + slacks(i) + 6139 state_dependent_transits(i) 6140 6141 where slack is a positive slack variable (can represent waiting times for 6142 a time dimension), and state_dependent_transits is a non-purely functional 6143 version of transits_. Favour transits over state_dependent_transits when 6144 possible, because purely functional callbacks allow more optimisations and 6145 make the model faster and easier to solve. 6146 for a given vehicle, it is passed as an external vector, it would be better 6147 to have this information here. 6148 """ 6149 6150 thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag") 6151 6152 def __init__(self, *args, **kwargs): 6153 raise AttributeError("No constructor defined") 6154 __repr__ = _swig_repr 6155 __swig_destroy__ = _pywrapcp.delete_RoutingDimension 6156 6157 def model(self): 6158 r""" Returns the model on which the dimension was created.""" 6159 return _pywrapcp.RoutingDimension_model(self) 6160 6161 def GetTransitValue(self, from_index, to_index, vehicle): 6162 r""" 6163 Returns the transition value for a given pair of nodes (as var index); 6164 this value is the one taken by the corresponding transit variable when 6165 the 'next' variable for 'from_index' is bound to 'to_index'. 6166 """ 6167 return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle) 6168 6169 def GetTransitValueFromClass(self, from_index, to_index, vehicle_class): 6170 r""" 6171 Same as above but taking a vehicle class of the dimension instead of a 6172 vehicle (the class of a vehicle can be obtained with vehicle_to_class()). 6173 """ 6174 return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class) 6175 6176 def CumulVar(self, index): 6177 r""" 6178 Get the cumul, transit and slack variables for the given node (given as 6179 int64_t var index). 6180 """ 6181 return _pywrapcp.RoutingDimension_CumulVar(self, index) 6182 6183 def TransitVar(self, index): 6184 return _pywrapcp.RoutingDimension_TransitVar(self, index) 6185 6186 def FixedTransitVar(self, index): 6187 return _pywrapcp.RoutingDimension_FixedTransitVar(self, index) 6188 6189 def SlackVar(self, index): 6190 return _pywrapcp.RoutingDimension_SlackVar(self, index) 6191 6192 def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle): 6193 r""" 6194 Sets an upper bound on the dimension span on a given vehicle. This is the 6195 preferred way to limit the "length" of the route of a vehicle according to 6196 a dimension. 6197 """ 6198 return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle) 6199 6200 def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle): 6201 r""" 6202 Sets a cost proportional to the dimension span on a given vehicle, 6203 or on all vehicles at once. "coefficient" must be nonnegative. 6204 This is handy to model costs proportional to idle time when the dimension 6205 represents time. 6206 The cost for a vehicle is 6207 span_cost = coefficient * (dimension end value - dimension start value). 6208 """ 6209 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle) 6210 6211 def SetSpanCostCoefficientForAllVehicles(self, coefficient): 6212 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForAllVehicles(self, coefficient) 6213 6214 def SetGlobalSpanCostCoefficient(self, coefficient): 6215 r""" 6216 Sets a cost proportional to the *global* dimension span, that is the 6217 difference between the largest value of route end cumul variables and 6218 the smallest value of route start cumul variables. 6219 In other words: 6220 global_span_cost = 6221 coefficient * (Max(dimension end value) - Min(dimension start value)). 6222 """ 6223 return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient) 6224 6225 def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient): 6226 r""" 6227 Sets a soft upper bound to the cumul variable of a given variable index. 6228 If the value of the cumul variable is greater than the bound, a cost 6229 proportional to the difference between this value and the bound is added 6230 to the cost function of the model: 6231 cumulVar <= upper_bound -> cost = 0 6232 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) 6233 This is also handy to model tardiness costs when the dimension represents 6234 time. 6235 """ 6236 return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient) 6237 6238 def HasCumulVarSoftUpperBound(self, index): 6239 r""" 6240 Returns true if a soft upper bound has been set for a given variable 6241 index. 6242 """ 6243 return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index) 6244 6245 def GetCumulVarSoftUpperBound(self, index): 6246 r""" 6247 Returns the soft upper bound of a cumul variable for a given variable 6248 index. The "hard" upper bound of the variable is returned if no soft upper 6249 bound has been set. 6250 """ 6251 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index) 6252 6253 def GetCumulVarSoftUpperBoundCoefficient(self, index): 6254 r""" 6255 Returns the cost coefficient of the soft upper bound of a cumul variable 6256 for a given variable index. If no soft upper bound has been set, 0 is 6257 returned. 6258 """ 6259 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index) 6260 6261 def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient): 6262 r""" 6263 Sets a soft lower bound to the cumul variable of a given variable index. 6264 If the value of the cumul variable is less than the bound, a cost 6265 proportional to the difference between this value and the bound is added 6266 to the cost function of the model: 6267 cumulVar > lower_bound -> cost = 0 6268 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - 6269 cumulVar). 6270 This is also handy to model earliness costs when the dimension represents 6271 time. 6272 """ 6273 return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient) 6274 6275 def HasCumulVarSoftLowerBound(self, index): 6276 r""" 6277 Returns true if a soft lower bound has been set for a given variable 6278 index. 6279 """ 6280 return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index) 6281 6282 def GetCumulVarSoftLowerBound(self, index): 6283 r""" 6284 Returns the soft lower bound of a cumul variable for a given variable 6285 index. The "hard" lower bound of the variable is returned if no soft lower 6286 bound has been set. 6287 """ 6288 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index) 6289 6290 def GetCumulVarSoftLowerBoundCoefficient(self, index): 6291 r""" 6292 Returns the cost coefficient of the soft lower bound of a cumul variable 6293 for a given variable index. If no soft lower bound has been set, 0 is 6294 returned. 6295 """ 6296 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index) 6297 6298 def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits): 6299 r""" 6300 Sets the breaks for a given vehicle. Breaks are represented by 6301 IntervalVars. They may interrupt transits between nodes and increase 6302 the value of corresponding slack variables. 6303 A break may take place before the start of a vehicle, after the end of 6304 a vehicle, or during a travel i -> j. 6305 6306 In that case, the interval [break.Start(), break.End()) must be a subset 6307 of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In 6308 other words, a break may not overlap any node n's visit, given by 6309 [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). 6310 This formula considers post_travel(_, start) and pre_travel(end, _) to be 6311 0; pre_travel will never be called on any (_, start) and post_travel will 6312 never we called on any (end, _). If pre_travel_evaluator or 6313 post_travel_evaluator is -1, it will be taken as a function that always 6314 returns 0. 6315 Deprecated, sets pre_travel(i, j) = node_visit_transit[i]. 6316 """ 6317 return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits) 6318 6319 def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle): 6320 r""" 6321 With breaks supposed to be consecutive, this forces the distance between 6322 breaks of size at least minimum_break_duration to be at most distance. 6323 This supposes that the time until route start and after route end are 6324 infinite breaks. 6325 """ 6326 return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle) 6327 6328 def InitializeBreaks(self): 6329 r""" 6330 Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, 6331 pre_travel_evaluators and post_travel_evaluators. 6332 """ 6333 return _pywrapcp.RoutingDimension_InitializeBreaks(self) 6334 6335 def HasBreakConstraints(self): 6336 r""" Returns true if any break interval or break distance was defined.""" 6337 return _pywrapcp.RoutingDimension_HasBreakConstraints(self) 6338 6339 def GetPreTravelEvaluatorOfVehicle(self, vehicle): 6340 return _pywrapcp.RoutingDimension_GetPreTravelEvaluatorOfVehicle(self, vehicle) 6341 6342 def GetPostTravelEvaluatorOfVehicle(self, vehicle): 6343 return _pywrapcp.RoutingDimension_GetPostTravelEvaluatorOfVehicle(self, vehicle) 6344 6345 def base_dimension(self): 6346 r""" Returns the parent in the dependency tree if any or nullptr otherwise.""" 6347 return _pywrapcp.RoutingDimension_base_dimension(self) 6348 6349 def ShortestTransitionSlack(self, node): 6350 r""" 6351 It makes sense to use the function only for self-dependent dimension. 6352 For such dimensions the value of the slack of a node determines the 6353 transition cost of the next transit. Provided that 6354 1. cumul[node] is fixed, 6355 2. next[node] and next[next[node]] (if exists) are fixed, 6356 the value of slack[node] for which cumul[next[node]] + transit[next[node]] 6357 is minimized can be found in O(1) using this function. 6358 """ 6359 return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node) 6360 6361 def name(self): 6362 r""" Returns the name of the dimension.""" 6363 return _pywrapcp.RoutingDimension_name(self) 6364 6365 def SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index): 6366 return _pywrapcp.RoutingDimension_SetPickupToDeliveryLimitFunctionForPair(self, limit_function, pair_index) 6367 6368 def HasPickupToDeliveryLimits(self): 6369 return _pywrapcp.RoutingDimension_HasPickupToDeliveryLimits(self) 6370 6371 def AddNodePrecedence(self, first_node, second_node, offset): 6372 return _pywrapcp.RoutingDimension_AddNodePrecedence(self, first_node, second_node, offset) 6373 6374 def GetSpanUpperBoundForVehicle(self, vehicle): 6375 return _pywrapcp.RoutingDimension_GetSpanUpperBoundForVehicle(self, vehicle) 6376 6377 def GetSpanCostCoefficientForVehicle(self, vehicle): 6378 return _pywrapcp.RoutingDimension_GetSpanCostCoefficientForVehicle(self, vehicle) 6379 6380 def global_span_cost_coefficient(self): 6381 return _pywrapcp.RoutingDimension_global_span_cost_coefficient(self) 6382 6383 def GetGlobalOptimizerOffset(self): 6384 return _pywrapcp.RoutingDimension_GetGlobalOptimizerOffset(self) 6385 6386 def GetLocalOptimizerOffsetForVehicle(self, vehicle): 6387 return _pywrapcp.RoutingDimension_GetLocalOptimizerOffsetForVehicle(self, vehicle) 6388 6389 def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6390 r""" 6391 If the span of vehicle on this dimension is larger than bound, 6392 the cost will be increased by cost * (span - bound). 6393 """ 6394 return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6395 6396 def HasSoftSpanUpperBounds(self): 6397 return _pywrapcp.RoutingDimension_HasSoftSpanUpperBounds(self) 6398 6399 def GetSoftSpanUpperBoundForVehicle(self, vehicle): 6400 return _pywrapcp.RoutingDimension_GetSoftSpanUpperBoundForVehicle(self, vehicle) 6401 6402 def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6403 r""" 6404 If the span of vehicle on this dimension is larger than bound, 6405 the cost will be increased by cost * (span - bound)^2. 6406 """ 6407 return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle) 6408 6409 def HasQuadraticCostSoftSpanUpperBounds(self): 6410 return _pywrapcp.RoutingDimension_HasQuadraticCostSoftSpanUpperBounds(self) 6411 6412 def GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle): 6413 return _pywrapcp.RoutingDimension_GetQuadraticCostSoftSpanUpperBoundForVehicle(self, vehicle)
Dimensions represent quantities accumulated at nodes along the routes. They represent quantities such as weights or volumes carried along the route, or distance or times.
Quantities at a node are represented by "cumul" variables and the increase or decrease of quantities between nodes are represented by "transit" variables. These variables are linked as follows:
if j == next(i), cumuls(j) = cumuls(i) + transits(i) + slacks(i) + state_dependent_transits(i)
where slack is a positive slack variable (can represent waiting times for a time dimension), and state_dependent_transits is a non-purely functional version of transits_. Favour transits over state_dependent_transits when possible, because purely functional callbacks allow more optimisations and make the model faster and easier to solve. for a given vehicle, it is passed as an external vector, it would be better to have this information here.
def
model(self):
6157 def model(self): 6158 r""" Returns the model on which the dimension was created.""" 6159 return _pywrapcp.RoutingDimension_model(self)
Returns the model on which the dimension was created.
def
GetTransitValue(self, from_index, to_index, vehicle):
6161 def GetTransitValue(self, from_index, to_index, vehicle): 6162 r""" 6163 Returns the transition value for a given pair of nodes (as var index); 6164 this value is the one taken by the corresponding transit variable when 6165 the 'next' variable for 'from_index' is bound to 'to_index'. 6166 """ 6167 return _pywrapcp.RoutingDimension_GetTransitValue(self, from_index, to_index, vehicle)
Returns the transition value for a given pair of nodes (as var index); this value is the one taken by the corresponding transit variable when the 'next' variable for 'from_index' is bound to 'to_index'.
def
GetTransitValueFromClass(self, from_index, to_index, vehicle_class):
6169 def GetTransitValueFromClass(self, from_index, to_index, vehicle_class): 6170 r""" 6171 Same as above but taking a vehicle class of the dimension instead of a 6172 vehicle (the class of a vehicle can be obtained with vehicle_to_class()). 6173 """ 6174 return _pywrapcp.RoutingDimension_GetTransitValueFromClass(self, from_index, to_index, vehicle_class)
Same as above but taking a vehicle class of the dimension instead of a vehicle (the class of a vehicle can be obtained with vehicle_to_class()).
def
CumulVar(self, index):
6176 def CumulVar(self, index): 6177 r""" 6178 Get the cumul, transit and slack variables for the given node (given as 6179 int64_t var index). 6180 """ 6181 return _pywrapcp.RoutingDimension_CumulVar(self, index)
Get the cumul, transit and slack variables for the given node (given as int64_t var index).
def
SetSpanUpperBoundForVehicle(self, upper_bound, vehicle):
6192 def SetSpanUpperBoundForVehicle(self, upper_bound, vehicle): 6193 r""" 6194 Sets an upper bound on the dimension span on a given vehicle. This is the 6195 preferred way to limit the "length" of the route of a vehicle according to 6196 a dimension. 6197 """ 6198 return _pywrapcp.RoutingDimension_SetSpanUpperBoundForVehicle(self, upper_bound, vehicle)
Sets an upper bound on the dimension span on a given vehicle. This is the preferred way to limit the "length" of the route of a vehicle according to a dimension.
def
SetSpanCostCoefficientForVehicle(self, coefficient, vehicle):
6200 def SetSpanCostCoefficientForVehicle(self, coefficient, vehicle): 6201 r""" 6202 Sets a cost proportional to the dimension span on a given vehicle, 6203 or on all vehicles at once. "coefficient" must be nonnegative. 6204 This is handy to model costs proportional to idle time when the dimension 6205 represents time. 6206 The cost for a vehicle is 6207 span_cost = coefficient * (dimension end value - dimension start value). 6208 """ 6209 return _pywrapcp.RoutingDimension_SetSpanCostCoefficientForVehicle(self, coefficient, vehicle)
Sets a cost proportional to the dimension span on a given vehicle, or on all vehicles at once. "coefficient" must be nonnegative. This is handy to model costs proportional to idle time when the dimension represents time. The cost for a vehicle is span_cost = coefficient * (dimension end value - dimension start value).
def
SetGlobalSpanCostCoefficient(self, coefficient):
6214 def SetGlobalSpanCostCoefficient(self, coefficient): 6215 r""" 6216 Sets a cost proportional to the *global* dimension span, that is the 6217 difference between the largest value of route end cumul variables and 6218 the smallest value of route start cumul variables. 6219 In other words: 6220 global_span_cost = 6221 coefficient * (Max(dimension end value) - Min(dimension start value)). 6222 """ 6223 return _pywrapcp.RoutingDimension_SetGlobalSpanCostCoefficient(self, coefficient)
Sets a cost proportional to the global dimension span, that is the difference between the largest value of route end cumul variables and the smallest value of route start cumul variables. In other words: global_span_cost = coefficient * (Max(dimension end value) - Min(dimension start value)).
def
SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient):
6225 def SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient): 6226 r""" 6227 Sets a soft upper bound to the cumul variable of a given variable index. 6228 If the value of the cumul variable is greater than the bound, a cost 6229 proportional to the difference between this value and the bound is added 6230 to the cost function of the model: 6231 cumulVar <= upper_bound -> cost = 0 6232 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) 6233 This is also handy to model tardiness costs when the dimension represents 6234 time. 6235 """ 6236 return _pywrapcp.RoutingDimension_SetCumulVarSoftUpperBound(self, index, upper_bound, coefficient)
Sets a soft upper bound to the cumul variable of a given variable index. If the value of the cumul variable is greater than the bound, a cost proportional to the difference between this value and the bound is added to the cost function of the model: cumulVar <= upper_bound -> cost = 0 cumulVar > upper_bound -> cost = coefficient * (cumulVar - upper_bound) This is also handy to model tardiness costs when the dimension represents time.
def
HasCumulVarSoftUpperBound(self, index):
6238 def HasCumulVarSoftUpperBound(self, index): 6239 r""" 6240 Returns true if a soft upper bound has been set for a given variable 6241 index. 6242 """ 6243 return _pywrapcp.RoutingDimension_HasCumulVarSoftUpperBound(self, index)
Returns true if a soft upper bound has been set for a given variable index.
def
GetCumulVarSoftUpperBound(self, index):
6245 def GetCumulVarSoftUpperBound(self, index): 6246 r""" 6247 Returns the soft upper bound of a cumul variable for a given variable 6248 index. The "hard" upper bound of the variable is returned if no soft upper 6249 bound has been set. 6250 """ 6251 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBound(self, index)
Returns the soft upper bound of a cumul variable for a given variable index. The "hard" upper bound of the variable is returned if no soft upper bound has been set.
def
GetCumulVarSoftUpperBoundCoefficient(self, index):
6253 def GetCumulVarSoftUpperBoundCoefficient(self, index): 6254 r""" 6255 Returns the cost coefficient of the soft upper bound of a cumul variable 6256 for a given variable index. If no soft upper bound has been set, 0 is 6257 returned. 6258 """ 6259 return _pywrapcp.RoutingDimension_GetCumulVarSoftUpperBoundCoefficient(self, index)
Returns the cost coefficient of the soft upper bound of a cumul variable for a given variable index. If no soft upper bound has been set, 0 is returned.
def
SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient):
6261 def SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient): 6262 r""" 6263 Sets a soft lower bound to the cumul variable of a given variable index. 6264 If the value of the cumul variable is less than the bound, a cost 6265 proportional to the difference between this value and the bound is added 6266 to the cost function of the model: 6267 cumulVar > lower_bound -> cost = 0 6268 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - 6269 cumulVar). 6270 This is also handy to model earliness costs when the dimension represents 6271 time. 6272 """ 6273 return _pywrapcp.RoutingDimension_SetCumulVarSoftLowerBound(self, index, lower_bound, coefficient)
Sets a soft lower bound to the cumul variable of a given variable index. If the value of the cumul variable is less than the bound, a cost proportional to the difference between this value and the bound is added to the cost function of the model: cumulVar > lower_bound -> cost = 0 cumulVar <= lower_bound -> cost = coefficient * (lower_bound - cumulVar). This is also handy to model earliness costs when the dimension represents time.
def
HasCumulVarSoftLowerBound(self, index):
6275 def HasCumulVarSoftLowerBound(self, index): 6276 r""" 6277 Returns true if a soft lower bound has been set for a given variable 6278 index. 6279 """ 6280 return _pywrapcp.RoutingDimension_HasCumulVarSoftLowerBound(self, index)
Returns true if a soft lower bound has been set for a given variable index.
def
GetCumulVarSoftLowerBound(self, index):
6282 def GetCumulVarSoftLowerBound(self, index): 6283 r""" 6284 Returns the soft lower bound of a cumul variable for a given variable 6285 index. The "hard" lower bound of the variable is returned if no soft lower 6286 bound has been set. 6287 """ 6288 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBound(self, index)
Returns the soft lower bound of a cumul variable for a given variable index. The "hard" lower bound of the variable is returned if no soft lower bound has been set.
def
GetCumulVarSoftLowerBoundCoefficient(self, index):
6290 def GetCumulVarSoftLowerBoundCoefficient(self, index): 6291 r""" 6292 Returns the cost coefficient of the soft lower bound of a cumul variable 6293 for a given variable index. If no soft lower bound has been set, 0 is 6294 returned. 6295 """ 6296 return _pywrapcp.RoutingDimension_GetCumulVarSoftLowerBoundCoefficient(self, index)
Returns the cost coefficient of the soft lower bound of a cumul variable for a given variable index. If no soft lower bound has been set, 0 is returned.
def
SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits):
6298 def SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits): 6299 r""" 6300 Sets the breaks for a given vehicle. Breaks are represented by 6301 IntervalVars. They may interrupt transits between nodes and increase 6302 the value of corresponding slack variables. 6303 A break may take place before the start of a vehicle, after the end of 6304 a vehicle, or during a travel i -> j. 6305 6306 In that case, the interval [break.Start(), break.End()) must be a subset 6307 of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In 6308 other words, a break may not overlap any node n's visit, given by 6309 [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). 6310 This formula considers post_travel(_, start) and pre_travel(end, _) to be 6311 0; pre_travel will never be called on any (_, start) and post_travel will 6312 never we called on any (end, _). If pre_travel_evaluator or 6313 post_travel_evaluator is -1, it will be taken as a function that always 6314 returns 0. 6315 Deprecated, sets pre_travel(i, j) = node_visit_transit[i]. 6316 """ 6317 return _pywrapcp.RoutingDimension_SetBreakIntervalsOfVehicle(self, breaks, vehicle, node_visit_transits)
Sets the breaks for a given vehicle. Breaks are represented by IntervalVars. They may interrupt transits between nodes and increase the value of corresponding slack variables. A break may take place before the start of a vehicle, after the end of a vehicle, or during a travel i -> j.
In that case, the interval [break.Start(), break.End()) must be a subset of [CumulVar(i) + pre_travel(i, j), CumulVar(j) - post_travel(i, j)). In other words, a break may not overlap any node n's visit, given by [CumulVar(n) - post_travel(_, n), CumulVar(n) + pre_travel(n, _)). This formula considers post_travel(_, start) and pre_travel(end, _) to be 0; pre_travel will never be called on any (_, start) and post_travel will never we called on any (end, _). If pre_travel_evaluator or post_travel_evaluator is -1, it will be taken as a function that always returns 0. Deprecated, sets pre_travel(i, j) = node_visit_transit[i].
def
SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle):
6319 def SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle): 6320 r""" 6321 With breaks supposed to be consecutive, this forces the distance between 6322 breaks of size at least minimum_break_duration to be at most distance. 6323 This supposes that the time until route start and after route end are 6324 infinite breaks. 6325 """ 6326 return _pywrapcp.RoutingDimension_SetBreakDistanceDurationOfVehicle(self, distance, duration, vehicle)
With breaks supposed to be consecutive, this forces the distance between breaks of size at least minimum_break_duration to be at most distance. This supposes that the time until route start and after route end are infinite breaks.
def
InitializeBreaks(self):
6328 def InitializeBreaks(self): 6329 r""" 6330 Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, 6331 pre_travel_evaluators and post_travel_evaluators. 6332 """ 6333 return _pywrapcp.RoutingDimension_InitializeBreaks(self)
Sets up vehicle_break_intervals_, vehicle_break_distance_duration_, pre_travel_evaluators and post_travel_evaluators.
def
HasBreakConstraints(self):
6335 def HasBreakConstraints(self): 6336 r""" Returns true if any break interval or break distance was defined.""" 6337 return _pywrapcp.RoutingDimension_HasBreakConstraints(self)
Returns true if any break interval or break distance was defined.
def
base_dimension(self):
6345 def base_dimension(self): 6346 r""" Returns the parent in the dependency tree if any or nullptr otherwise.""" 6347 return _pywrapcp.RoutingDimension_base_dimension(self)
Returns the parent in the dependency tree if any or nullptr otherwise.
def
ShortestTransitionSlack(self, node):
6349 def ShortestTransitionSlack(self, node): 6350 r""" 6351 It makes sense to use the function only for self-dependent dimension. 6352 For such dimensions the value of the slack of a node determines the 6353 transition cost of the next transit. Provided that 6354 1. cumul[node] is fixed, 6355 2. next[node] and next[next[node]] (if exists) are fixed, 6356 the value of slack[node] for which cumul[next[node]] + transit[next[node]] 6357 is minimized can be found in O(1) using this function. 6358 """ 6359 return _pywrapcp.RoutingDimension_ShortestTransitionSlack(self, node)
It makes sense to use the function only for self-dependent dimension. For such dimensions the value of the slack of a node determines the transition cost of the next transit. Provided that
- cumul[node] is fixed,
- next[node] and next[next[node]] (if exists) are fixed, the value of slack[node] for which cumul[next[node]] + transit[next[node]] is minimized can be found in O(1) using this function.
def
name(self):
6361 def name(self): 6362 r""" Returns the name of the dimension.""" 6363 return _pywrapcp.RoutingDimension_name(self)
Returns the name of the dimension.
def
SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6389 def SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6390 r""" 6391 If the span of vehicle on this dimension is larger than bound, 6392 the cost will be increased by cost * (span - bound). 6393 """ 6394 return _pywrapcp.RoutingDimension_SetSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
If the span of vehicle on this dimension is larger than bound, the cost will be increased by cost * (span - bound).
def
SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle):
6402 def SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle): 6403 r""" 6404 If the span of vehicle on this dimension is larger than bound, 6405 the cost will be increased by cost * (span - bound)^2. 6406 """ 6407 return _pywrapcp.RoutingDimension_SetQuadraticCostSoftSpanUpperBoundForVehicle(self, bound_cost, vehicle)
If the span of vehicle on this dimension is larger than bound, the cost will be increased by cost * (span - bound)^2.
def
SolveModelWithSat(model, search_parameters, initial_solution, solution):
6418def SolveModelWithSat(model, search_parameters, initial_solution, solution): 6419 r""" 6420 Attempts to solve the model using the cp-sat solver. As of 5/2019, will 6421 solve the TSP corresponding to the model if it has a single vehicle. 6422 Therefore the resulting solution might not actually be feasible. Will return 6423 false if a solution could not be found. 6424 """ 6425 return _pywrapcp.SolveModelWithSat(model, search_parameters, initial_solution, solution)
Attempts to solve the model using the cp-sat solver. As of 5/2019, will solve the TSP corresponding to the model if it has a single vehicle. Therefore the resulting solution might not actually be feasible. Will return false if a solution could not be found.